diff --git a/src/transformation/utils/function-context.ts b/src/transformation/utils/function-context.ts
index 6a2113d6a..8bf05255c 100644
--- a/src/transformation/utils/function-context.ts
+++ b/src/transformation/utils/function-context.ts
@@ -46,6 +46,11 @@ export function getDeclarationContextType(
             : ContextType.NonVoid;
     }
 
+    // noSelf declaration on function signature
+    if (getNodeAnnotations(signatureDeclaration).has(AnnotationKind.NoSelf)) {
+        return ContextType.Void;
+    }
+
     if (
         ts.isMethodSignature(signatureDeclaration) ||
         ts.isMethodDeclaration(signatureDeclaration) ||
diff --git a/test/unit/functions/__snapshots__/noSelfAnnotation.spec.ts.snap b/test/unit/functions/__snapshots__/noSelfAnnotation.spec.ts.snap
new file mode 100644
index 000000000..f4e5fdd6d
--- /dev/null
+++ b/test/unit/functions/__snapshots__/noSelfAnnotation.spec.ts.snap
@@ -0,0 +1,15 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`@noSelf on declared function removes context argument 1`] = `"myFunction()"`;
+
+exports[`@noSelf on method inside class declaration removes context argument 1`] = `"holder.myMethod()"`;
+
+exports[`@noSelf on method inside interface declaration removes context argument 1`] = `"holder.myMethod()"`;
+
+exports[`@noSelf on method inside namespace declaration removes context argument 1`] = `"MyNamespace.myMethod()"`;
+
+exports[`@noSelf on parent class declaration removes context argument 1`] = `"holder.myMethod()"`;
+
+exports[`@noSelf on parent interface declaration removes context argument 1`] = `"holder.myMethod()"`;
+
+exports[`@noSelf on parent namespace declaration removes context argument 1`] = `"MyNamespace.myMethod()"`;
diff --git a/test/unit/functions/noSelfAnnotation.spec.ts b/test/unit/functions/noSelfAnnotation.spec.ts
new file mode 100644
index 000000000..ab77ec03e
--- /dev/null
+++ b/test/unit/functions/noSelfAnnotation.spec.ts
@@ -0,0 +1,53 @@
+import * as util from "../../util";
+
+const methodHolders = ["class", "interface"];
+
+test("@noSelf on declared function removes context argument", () => {
+    util.testModule`
+        /** @noSelf */
+        declare function myFunction(): void;
+        myFunction();
+    `.expectLuaToMatchSnapshot();
+});
+
+test.each(methodHolders)("@noSelf on method inside %s declaration removes context argument", holderType => {
+    util.testModule`
+        declare ${holderType} MethodHolder {
+            /** @noSelf */
+            myMethod(): void;
+        }
+        declare const holder: MethodHolder;
+        holder.myMethod();
+    `.expectLuaToMatchSnapshot();
+});
+
+test.each(methodHolders)("@noSelf on parent %s declaration removes context argument", holderType => {
+    util.testModule`
+        /** @noSelf */
+        declare ${holderType} MethodHolder {
+            myMethod(): void;
+        }
+        declare const holder: MethodHolder;
+        holder.myMethod();
+    `.expectLuaToMatchSnapshot();
+});
+
+test("@noSelf on method inside namespace declaration removes context argument", () => {
+    util.testModule`
+        declare namespace MyNamespace {
+            /** @noSelf */
+            export function myMethod(): void;
+        }
+        MyNamespace.myMethod();
+    `.expectLuaToMatchSnapshot();
+});
+
+test("@noSelf on parent namespace declaration removes context argument", () => {
+    util.testModule`
+        /** @noSelf */
+        declare namespace MyNamespace {
+            export function myMethod(): void;
+        }
+        MyNamespace.myMethod();
+    `.expectLuaToMatchSnapshot();
+});
diff --git a/test/unit/functions/validation/__snapshots__/invalidFunctionAssignments.spec.ts.snap b/test/unit/functions/validation/__snapshots__/invalidFunctionAssignments.spec.ts.snap
index 9f112f305..55e61f9ae 100644
--- a/test/unit/functions/validation/__snapshots__/invalidFunctionAssignments.spec.ts.snap
+++ b/test/unit/functions/validation/__snapshots__/invalidFunctionAssignments.spec.ts.snap
@@ -179,6 +179,18 @@ exports[`Invalid function argument ({"definition": "class NoSelfAnonFuncNSMerged
 exports[`Invalid function argument ({"definition": "class NoSelfAnonFuncNSMergedClass { method(s: string): string { return s; } }
         /** @noSelf */ namespace NoSelfAnonFuncNSMergedClass { export function nsFunc(s: string) { return s; } }", "value": "NoSelfAnonFuncNSMergedClass.nsFunc"}): diagnostics 2`] = `"main.ts(5,27): error TSTL: Unable to convert function with no 'this' parameter to function 'fn' with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
 
+exports[`Invalid function argument ({"definition": "class NoSelfMethodClass { 
+                /** @noSelf */
+                noSelfMethod(s: string): string { return s; } 
+            }
+            const noSelfMethodClass = new NoSelfMethodClass();", "value": "noSelfMethodClass.noSelfMethod"}): diagnostics 1`] = `"main.ts(8,27): error TSTL: Unable to convert function with no 'this' parameter to function 'fn' with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
+
+exports[`Invalid function argument ({"definition": "class NoSelfMethodClass { 
+                /** @noSelf */
+                noSelfMethod(s: string): string { return s; } 
+            }
+            const noSelfMethodClass = new NoSelfMethodClass();", "value": "noSelfMethodClass.noSelfMethod"}): diagnostics 2`] = `"main.ts(8,27): error TSTL: Unable to convert function with no 'this' parameter to function 'fn' with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
+
 exports[`Invalid function argument ({"definition": "class StaticFuncPropClass {
                 static staticFuncProp: (this: any, s: string) => string = s => s;
             }", "value": "StaticFuncPropClass.staticFuncProp"}): diagnostics 1`] = `"main.ts(6,27): error TSTL: Unable to convert function with a 'this' parameter to function 'fn' with no 'this'. To fix, wrap in an arrow function, or declare with 'this: void'."`;
@@ -237,6 +249,22 @@ exports[`Invalid function argument ({"definition": "interface FuncPropInterface
 exports[`Invalid function argument ({"definition": "interface MethodInterface { method(this: any, s: string): string; }
             const methodInterface: MethodInterface = { method: function(this: any, s: string): string { return s; } }", "value": "methodInterface.method"}): diagnostics 1`] = `"main.ts(5,27): error TSTL: Unable to convert function with a 'this' parameter to function 'fn' with no 'this'. To fix, wrap in an arrow function, or declare with 'this: void'."`;
 
+exports[`Invalid function argument ({"definition": "interface NoSelfMethodInterface { 
+                /** @noSelf */ 
+                noSelfMethod(s: string): string;
+            }
+            const noSelfMethodInterface: NoSelfMethodInterface = {
+                noSelfMethod: function(s: string): string { return s; }
+            };", "value": "noSelfMethodInterface.noSelfMethod"}): diagnostics 1`] = `"main.ts(10,27): error TSTL: Unable to convert function with no 'this' parameter to function 'fn' with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
+
+exports[`Invalid function argument ({"definition": "interface NoSelfMethodInterface { 
+                /** @noSelf */ 
+                noSelfMethod(s: string): string;
+            }
+            const noSelfMethodInterface: NoSelfMethodInterface = {
+                noSelfMethod: function(s: string): string { return s; }
+            };", "value": "noSelfMethodInterface.noSelfMethod"}): diagnostics 2`] = `"main.ts(10,27): error TSTL: Unable to convert function with no 'this' parameter to function 'fn' with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
+
 exports[`Invalid function argument ({"definition": "interface VoidFuncPropInterface {
                 voidFuncProp: (this: void, s: string) => string;
             }
@@ -301,6 +329,14 @@ exports[`Invalid function argument ({"definition": "namespace NoSelfAnonFuncNSMe
 exports[`Invalid function argument ({"definition": "namespace NoSelfAnonFuncNSMergedSelfNS { export function nsFuncSelf(s: string): string { return s; } }
         /** @noSelf */ namespace NoSelfAnonFuncNSMergedSelfNS { export function nsFuncNoSelf(s: string) { return s; } }", "value": "NoSelfAnonFuncNSMergedSelfNS.nsFuncNoSelf"}): diagnostics 2`] = `"main.ts(5,27): error TSTL: Unable to convert function with no 'this' parameter to function 'fn' with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
 
+exports[`Invalid function argument ({"definition": "namespace NoSelfFuncNs {
+            /** @noSelf */
+            export function noSelfNsFunc(s: string) { return s; } }", "value": "NoSelfFuncNs.noSelfNsFunc"}): diagnostics 1`] = `"main.ts(6,27): error TSTL: Unable to convert function with no 'this' parameter to function 'fn' with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
+
+exports[`Invalid function argument ({"definition": "namespace NoSelfFuncNs {
+            /** @noSelf */
+            export function noSelfNsFunc(s: string) { return s; } }", "value": "NoSelfFuncNs.noSelfNsFunc"}): diagnostics 2`] = `"main.ts(6,27): error TSTL: Unable to convert function with no 'this' parameter to function 'fn' with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
+
 exports[`Invalid function argument ({"definition": "namespace SelfAnonFuncNSMergedNoSelfNS { export function nsFuncSelf(s: string): string { return s; } }
         /** @noSelf */ namespace SelfAnonFuncNSMergedNoSelfNS { export function nsFuncNoSelf(s: string) { return s; } }", "value": "SelfAnonFuncNSMergedNoSelfNS.nsFuncSelf"}): diagnostics 1`] = `"main.ts(5,27): error TSTL: Unable to convert function with a 'this' parameter to function 'fn' with no 'this'. To fix, wrap in an arrow function, or declare with 'this: void'."`;
 
@@ -535,6 +571,18 @@ exports[`Invalid function assignment ({"definition": "class NoSelfAnonFuncNSMerg
 exports[`Invalid function assignment ({"definition": "class NoSelfAnonFuncNSMergedClass { method(s: string): string { return s; } }
         /** @noSelf */ namespace NoSelfAnonFuncNSMergedClass { export function nsFunc(s: string) { return s; } }", "value": "NoSelfAnonFuncNSMergedClass.nsFunc"}): diagnostics 2`] = `"main.ts(5,18): error TSTL: Unable to convert function with no 'this' parameter to function with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
 
+exports[`Invalid function assignment ({"definition": "class NoSelfMethodClass { 
+                /** @noSelf */
+                noSelfMethod(s: string): string { return s; } 
+            }
+            const noSelfMethodClass = new NoSelfMethodClass();", "value": "noSelfMethodClass.noSelfMethod"}): diagnostics 1`] = `"main.ts(8,18): error TSTL: Unable to convert function with no 'this' parameter to function with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
+
+exports[`Invalid function assignment ({"definition": "class NoSelfMethodClass { 
+                /** @noSelf */
+                noSelfMethod(s: string): string { return s; } 
+            }
+            const noSelfMethodClass = new NoSelfMethodClass();", "value": "noSelfMethodClass.noSelfMethod"}): diagnostics 2`] = `"main.ts(8,18): error TSTL: Unable to convert function with no 'this' parameter to function with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
+
 exports[`Invalid function assignment ({"definition": "class StaticFuncPropClass {
                 static staticFuncProp: (this: any, s: string) => string = s => s;
             }", "value": "StaticFuncPropClass.staticFuncProp"}): diagnostics 1`] = `"main.ts(6,18): error TSTL: Unable to convert function with a 'this' parameter to function with no 'this'. To fix, wrap in an arrow function, or declare with 'this: void'."`;
@@ -593,6 +641,22 @@ exports[`Invalid function assignment ({"definition": "interface FuncPropInterfac
 exports[`Invalid function assignment ({"definition": "interface MethodInterface { method(this: any, s: string): string; }
             const methodInterface: MethodInterface = { method: function(this: any, s: string): string { return s; } }", "value": "methodInterface.method"}): diagnostics 1`] = `"main.ts(5,18): error TSTL: Unable to convert function with a 'this' parameter to function with no 'this'. To fix, wrap in an arrow function, or declare with 'this: void'."`;
 
+exports[`Invalid function assignment ({"definition": "interface NoSelfMethodInterface { 
+                /** @noSelf */ 
+                noSelfMethod(s: string): string;
+            }
+            const noSelfMethodInterface: NoSelfMethodInterface = {
+                noSelfMethod: function(s: string): string { return s; }
+            };", "value": "noSelfMethodInterface.noSelfMethod"}): diagnostics 1`] = `"main.ts(10,18): error TSTL: Unable to convert function with no 'this' parameter to function with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
+
+exports[`Invalid function assignment ({"definition": "interface NoSelfMethodInterface { 
+                /** @noSelf */ 
+                noSelfMethod(s: string): string;
+            }
+            const noSelfMethodInterface: NoSelfMethodInterface = {
+                noSelfMethod: function(s: string): string { return s; }
+            };", "value": "noSelfMethodInterface.noSelfMethod"}): diagnostics 2`] = `"main.ts(10,18): error TSTL: Unable to convert function with no 'this' parameter to function with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
+
 exports[`Invalid function assignment ({"definition": "interface VoidFuncPropInterface {
                 voidFuncProp: (this: void, s: string) => string;
             }
@@ -657,6 +721,14 @@ exports[`Invalid function assignment ({"definition": "namespace NoSelfAnonFuncNS
 exports[`Invalid function assignment ({"definition": "namespace NoSelfAnonFuncNSMergedSelfNS { export function nsFuncSelf(s: string): string { return s; } }
         /** @noSelf */ namespace NoSelfAnonFuncNSMergedSelfNS { export function nsFuncNoSelf(s: string) { return s; } }", "value": "NoSelfAnonFuncNSMergedSelfNS.nsFuncNoSelf"}): diagnostics 2`] = `"main.ts(5,18): error TSTL: Unable to convert function with no 'this' parameter to function with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
 
+exports[`Invalid function assignment ({"definition": "namespace NoSelfFuncNs {
+            /** @noSelf */
+            export function noSelfNsFunc(s: string) { return s; } }", "value": "NoSelfFuncNs.noSelfNsFunc"}): diagnostics 1`] = `"main.ts(6,18): error TSTL: Unable to convert function with no 'this' parameter to function with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
+
+exports[`Invalid function assignment ({"definition": "namespace NoSelfFuncNs {
+            /** @noSelf */
+            export function noSelfNsFunc(s: string) { return s; } }", "value": "NoSelfFuncNs.noSelfNsFunc"}): diagnostics 2`] = `"main.ts(6,18): error TSTL: Unable to convert function with no 'this' parameter to function with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
+
 exports[`Invalid function assignment ({"definition": "namespace SelfAnonFuncNSMergedNoSelfNS { export function nsFuncSelf(s: string): string { return s; } }
         /** @noSelf */ namespace SelfAnonFuncNSMergedNoSelfNS { export function nsFuncNoSelf(s: string) { return s; } }", "value": "SelfAnonFuncNSMergedNoSelfNS.nsFuncSelf"}): diagnostics 1`] = `"main.ts(5,18): error TSTL: Unable to convert function with a 'this' parameter to function with no 'this'. To fix, wrap in an arrow function, or declare with 'this: void'."`;
 
@@ -891,6 +963,18 @@ exports[`Invalid function generic argument ({"definition": "class NoSelfAnonFunc
 exports[`Invalid function generic argument ({"definition": "class NoSelfAnonFuncNSMergedClass { method(s: string): string { return s; } }
         /** @noSelf */ namespace NoSelfAnonFuncNSMergedClass { export function nsFunc(s: string) { return s; } }", "value": "NoSelfAnonFuncNSMergedClass.nsFunc"}): diagnostics 2`] = `"main.ts(5,27): error TSTL: Unable to convert function with no 'this' parameter to function 'fn' with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
 
+exports[`Invalid function generic argument ({"definition": "class NoSelfMethodClass { 
+                /** @noSelf */
+                noSelfMethod(s: string): string { return s; } 
+            }
+            const noSelfMethodClass = new NoSelfMethodClass();", "value": "noSelfMethodClass.noSelfMethod"}): diagnostics 1`] = `"main.ts(8,27): error TSTL: Unable to convert function with no 'this' parameter to function 'fn' with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
+
+exports[`Invalid function generic argument ({"definition": "class NoSelfMethodClass { 
+                /** @noSelf */
+                noSelfMethod(s: string): string { return s; } 
+            }
+            const noSelfMethodClass = new NoSelfMethodClass();", "value": "noSelfMethodClass.noSelfMethod"}): diagnostics 2`] = `"main.ts(8,27): error TSTL: Unable to convert function with no 'this' parameter to function 'fn' with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
+
 exports[`Invalid function generic argument ({"definition": "class StaticFuncPropClass {
                 static staticFuncProp: (this: any, s: string) => string = s => s;
             }", "value": "StaticFuncPropClass.staticFuncProp"}): diagnostics 1`] = `"main.ts(6,27): error TSTL: Unable to convert function with a 'this' parameter to function 'fn' with no 'this'. To fix, wrap in an arrow function, or declare with 'this: void'."`;
@@ -949,6 +1033,22 @@ exports[`Invalid function generic argument ({"definition": "interface FuncPropIn
 exports[`Invalid function generic argument ({"definition": "interface MethodInterface { method(this: any, s: string): string; }
             const methodInterface: MethodInterface = { method: function(this: any, s: string): string { return s; } }", "value": "methodInterface.method"}): diagnostics 1`] = `"main.ts(5,27): error TSTL: Unable to convert function with a 'this' parameter to function 'fn' with no 'this'. To fix, wrap in an arrow function, or declare with 'this: void'."`;
 
+exports[`Invalid function generic argument ({"definition": "interface NoSelfMethodInterface { 
+                /** @noSelf */ 
+                noSelfMethod(s: string): string;
+            }
+            const noSelfMethodInterface: NoSelfMethodInterface = {
+                noSelfMethod: function(s: string): string { return s; }
+            };", "value": "noSelfMethodInterface.noSelfMethod"}): diagnostics 1`] = `"main.ts(10,27): error TSTL: Unable to convert function with no 'this' parameter to function 'fn' with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
+
+exports[`Invalid function generic argument ({"definition": "interface NoSelfMethodInterface { 
+                /** @noSelf */ 
+                noSelfMethod(s: string): string;
+            }
+            const noSelfMethodInterface: NoSelfMethodInterface = {
+                noSelfMethod: function(s: string): string { return s; }
+            };", "value": "noSelfMethodInterface.noSelfMethod"}): diagnostics 2`] = `"main.ts(10,27): error TSTL: Unable to convert function with no 'this' parameter to function 'fn' with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
+
 exports[`Invalid function generic argument ({"definition": "interface VoidFuncPropInterface {
                 voidFuncProp: (this: void, s: string) => string;
             }
@@ -1013,6 +1113,14 @@ exports[`Invalid function generic argument ({"definition": "namespace NoSelfAnon
 exports[`Invalid function generic argument ({"definition": "namespace NoSelfAnonFuncNSMergedSelfNS { export function nsFuncSelf(s: string): string { return s; } }
         /** @noSelf */ namespace NoSelfAnonFuncNSMergedSelfNS { export function nsFuncNoSelf(s: string) { return s; } }", "value": "NoSelfAnonFuncNSMergedSelfNS.nsFuncNoSelf"}): diagnostics 2`] = `"main.ts(5,27): error TSTL: Unable to convert function with no 'this' parameter to function 'fn' with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
 
+exports[`Invalid function generic argument ({"definition": "namespace NoSelfFuncNs {
+            /** @noSelf */
+            export function noSelfNsFunc(s: string) { return s; } }", "value": "NoSelfFuncNs.noSelfNsFunc"}): diagnostics 1`] = `"main.ts(6,27): error TSTL: Unable to convert function with no 'this' parameter to function 'fn' with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
+
+exports[`Invalid function generic argument ({"definition": "namespace NoSelfFuncNs {
+            /** @noSelf */
+            export function noSelfNsFunc(s: string) { return s; } }", "value": "NoSelfFuncNs.noSelfNsFunc"}): diagnostics 2`] = `"main.ts(6,27): error TSTL: Unable to convert function with no 'this' parameter to function 'fn' with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
+
 exports[`Invalid function generic argument ({"definition": "namespace SelfAnonFuncNSMergedNoSelfNS { export function nsFuncSelf(s: string): string { return s; } }
         /** @noSelf */ namespace SelfAnonFuncNSMergedNoSelfNS { export function nsFuncNoSelf(s: string) { return s; } }", "value": "SelfAnonFuncNSMergedNoSelfNS.nsFuncSelf"}): diagnostics 1`] = `"main.ts(5,27): error TSTL: Unable to convert function with a 'this' parameter to function 'fn' with no 'this'. To fix, wrap in an arrow function, or declare with 'this: void'."`;
 
@@ -1215,6 +1323,18 @@ exports[`Invalid function return ({"definition": "class NoSelfAnonFuncNSMergedCl
 exports[`Invalid function return ({"definition": "class NoSelfAnonFuncNSMergedClass { method(s: string): string { return s; } }
         /** @noSelf */ namespace NoSelfAnonFuncNSMergedClass { export function nsFunc(s: string) { return s; } }", "value": "NoSelfAnonFuncNSMergedClass.nsFunc"}): diagnostics 2`] = `"main.ts(5,17): error TSTL: Unable to convert function with no 'this' parameter to function with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
 
+exports[`Invalid function return ({"definition": "class NoSelfMethodClass { 
+                /** @noSelf */
+                noSelfMethod(s: string): string { return s; } 
+            }
+            const noSelfMethodClass = new NoSelfMethodClass();", "value": "noSelfMethodClass.noSelfMethod"}): diagnostics 1`] = `"main.ts(8,17): error TSTL: Unable to convert function with no 'this' parameter to function with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
+
+exports[`Invalid function return ({"definition": "class NoSelfMethodClass { 
+                /** @noSelf */
+                noSelfMethod(s: string): string { return s; } 
+            }
+            const noSelfMethodClass = new NoSelfMethodClass();", "value": "noSelfMethodClass.noSelfMethod"}): diagnostics 2`] = `"main.ts(8,17): error TSTL: Unable to convert function with no 'this' parameter to function with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
+
 exports[`Invalid function return ({"definition": "class StaticFuncPropClass {
                 static staticFuncProp: (this: any, s: string) => string = s => s;
             }", "value": "StaticFuncPropClass.staticFuncProp"}): diagnostics 1`] = `"main.ts(6,17): error TSTL: Unable to convert function with a 'this' parameter to function with no 'this'. To fix, wrap in an arrow function, or declare with 'this: void'."`;
@@ -1273,6 +1393,22 @@ exports[`Invalid function return ({"definition": "interface FuncPropInterface {
 exports[`Invalid function return ({"definition": "interface MethodInterface { method(this: any, s: string): string; }
             const methodInterface: MethodInterface = { method: function(this: any, s: string): string { return s; } }", "value": "methodInterface.method"}): diagnostics 1`] = `"main.ts(5,17): error TSTL: Unable to convert function with a 'this' parameter to function with no 'this'. To fix, wrap in an arrow function, or declare with 'this: void'."`;
 
+exports[`Invalid function return ({"definition": "interface NoSelfMethodInterface { 
+                /** @noSelf */ 
+                noSelfMethod(s: string): string;
+            }
+            const noSelfMethodInterface: NoSelfMethodInterface = {
+                noSelfMethod: function(s: string): string { return s; }
+            };", "value": "noSelfMethodInterface.noSelfMethod"}): diagnostics 1`] = `"main.ts(10,17): error TSTL: Unable to convert function with no 'this' parameter to function with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
+
+exports[`Invalid function return ({"definition": "interface NoSelfMethodInterface { 
+                /** @noSelf */ 
+                noSelfMethod(s: string): string;
+            }
+            const noSelfMethodInterface: NoSelfMethodInterface = {
+                noSelfMethod: function(s: string): string { return s; }
+            };", "value": "noSelfMethodInterface.noSelfMethod"}): diagnostics 2`] = `"main.ts(10,17): error TSTL: Unable to convert function with no 'this' parameter to function with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
+
 exports[`Invalid function return ({"definition": "interface VoidFuncPropInterface {
                 voidFuncProp: (this: void, s: string) => string;
             }
@@ -1337,6 +1473,14 @@ exports[`Invalid function return ({"definition": "namespace NoSelfAnonFuncNSMerg
 exports[`Invalid function return ({"definition": "namespace NoSelfAnonFuncNSMergedSelfNS { export function nsFuncSelf(s: string): string { return s; } }
         /** @noSelf */ namespace NoSelfAnonFuncNSMergedSelfNS { export function nsFuncNoSelf(s: string) { return s; } }", "value": "NoSelfAnonFuncNSMergedSelfNS.nsFuncNoSelf"}): diagnostics 2`] = `"main.ts(5,17): error TSTL: Unable to convert function with no 'this' parameter to function with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
 
+exports[`Invalid function return ({"definition": "namespace NoSelfFuncNs {
+            /** @noSelf */
+            export function noSelfNsFunc(s: string) { return s; } }", "value": "NoSelfFuncNs.noSelfNsFunc"}): diagnostics 1`] = `"main.ts(6,17): error TSTL: Unable to convert function with no 'this' parameter to function with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
+
+exports[`Invalid function return ({"definition": "namespace NoSelfFuncNs {
+            /** @noSelf */
+            export function noSelfNsFunc(s: string) { return s; } }", "value": "NoSelfFuncNs.noSelfNsFunc"}): diagnostics 2`] = `"main.ts(6,17): error TSTL: Unable to convert function with no 'this' parameter to function with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
+
 exports[`Invalid function return ({"definition": "namespace SelfAnonFuncNSMergedNoSelfNS { export function nsFuncSelf(s: string): string { return s; } }
         /** @noSelf */ namespace SelfAnonFuncNSMergedNoSelfNS { export function nsFuncNoSelf(s: string) { return s; } }", "value": "SelfAnonFuncNSMergedNoSelfNS.nsFuncSelf"}): diagnostics 1`] = `"main.ts(5,17): error TSTL: Unable to convert function with a 'this' parameter to function with no 'this'. To fix, wrap in an arrow function, or declare with 'this: void'."`;
 
@@ -1579,6 +1723,18 @@ exports[`Invalid function variable declaration ({"definition": "class NoSelfAnon
 exports[`Invalid function variable declaration ({"definition": "class NoSelfAnonFuncNSMergedClass { method(s: string): string { return s; } }
         /** @noSelf */ namespace NoSelfAnonFuncNSMergedClass { export function nsFunc(s: string) { return s; } }", "value": "NoSelfAnonFuncNSMergedClass.nsFunc"}): diagnostics 2`] = `"main.ts(4,58): error TSTL: Unable to convert function with no 'this' parameter to function with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
 
+exports[`Invalid function variable declaration ({"definition": "class NoSelfMethodClass { 
+                /** @noSelf */
+                noSelfMethod(s: string): string { return s; } 
+            }
+            const noSelfMethodClass = new NoSelfMethodClass();", "value": "noSelfMethodClass.noSelfMethod"}): diagnostics 1`] = `"main.ts(7,47): error TSTL: Unable to convert function with no 'this' parameter to function with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
+
+exports[`Invalid function variable declaration ({"definition": "class NoSelfMethodClass { 
+                /** @noSelf */
+                noSelfMethod(s: string): string { return s; } 
+            }
+            const noSelfMethodClass = new NoSelfMethodClass();", "value": "noSelfMethodClass.noSelfMethod"}): diagnostics 2`] = `"main.ts(7,58): error TSTL: Unable to convert function with no 'this' parameter to function with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
+
 exports[`Invalid function variable declaration ({"definition": "class StaticFuncPropClass {
                 static staticFuncProp: (this: any, s: string) => string = s => s;
             }", "value": "StaticFuncPropClass.staticFuncProp"}): diagnostics 1`] = `"main.ts(5,59): error TSTL: Unable to convert function with a 'this' parameter to function with no 'this'. To fix, wrap in an arrow function, or declare with 'this: void'."`;
@@ -1637,6 +1793,22 @@ exports[`Invalid function variable declaration ({"definition": "interface FuncPr
 exports[`Invalid function variable declaration ({"definition": "interface MethodInterface { method(this: any, s: string): string; }
             const methodInterface: MethodInterface = { method: function(this: any, s: string): string { return s; } }", "value": "methodInterface.method"}): diagnostics 1`] = `"main.ts(4,59): error TSTL: Unable to convert function with a 'this' parameter to function with no 'this'. To fix, wrap in an arrow function, or declare with 'this: void'."`;
 
+exports[`Invalid function variable declaration ({"definition": "interface NoSelfMethodInterface { 
+                /** @noSelf */ 
+                noSelfMethod(s: string): string;
+            }
+            const noSelfMethodInterface: NoSelfMethodInterface = {
+                noSelfMethod: function(s: string): string { return s; }
+            };", "value": "noSelfMethodInterface.noSelfMethod"}): diagnostics 1`] = `"main.ts(9,47): error TSTL: Unable to convert function with no 'this' parameter to function with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
+
+exports[`Invalid function variable declaration ({"definition": "interface NoSelfMethodInterface { 
+                /** @noSelf */ 
+                noSelfMethod(s: string): string;
+            }
+            const noSelfMethodInterface: NoSelfMethodInterface = {
+                noSelfMethod: function(s: string): string { return s; }
+            };", "value": "noSelfMethodInterface.noSelfMethod"}): diagnostics 2`] = `"main.ts(9,58): error TSTL: Unable to convert function with no 'this' parameter to function with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
+
 exports[`Invalid function variable declaration ({"definition": "interface VoidFuncPropInterface {
                 voidFuncProp: (this: void, s: string) => string;
             }
@@ -1701,6 +1873,14 @@ exports[`Invalid function variable declaration ({"definition": "namespace NoSelf
 exports[`Invalid function variable declaration ({"definition": "namespace NoSelfAnonFuncNSMergedSelfNS { export function nsFuncSelf(s: string): string { return s; } }
         /** @noSelf */ namespace NoSelfAnonFuncNSMergedSelfNS { export function nsFuncNoSelf(s: string) { return s; } }", "value": "NoSelfAnonFuncNSMergedSelfNS.nsFuncNoSelf"}): diagnostics 2`] = `"main.ts(4,58): error TSTL: Unable to convert function with no 'this' parameter to function with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
 
+exports[`Invalid function variable declaration ({"definition": "namespace NoSelfFuncNs {
+            /** @noSelf */
+            export function noSelfNsFunc(s: string) { return s; } }", "value": "NoSelfFuncNs.noSelfNsFunc"}): diagnostics 1`] = `"main.ts(5,47): error TSTL: Unable to convert function with no 'this' parameter to function with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
+
+exports[`Invalid function variable declaration ({"definition": "namespace NoSelfFuncNs {
+            /** @noSelf */
+            export function noSelfNsFunc(s: string) { return s; } }", "value": "NoSelfFuncNs.noSelfNsFunc"}): diagnostics 2`] = `"main.ts(5,58): error TSTL: Unable to convert function with no 'this' parameter to function with 'this'. To fix, wrap in an arrow function, or declare with 'this: any'."`;
+
 exports[`Invalid function variable declaration ({"definition": "namespace SelfAnonFuncNSMergedNoSelfNS { export function nsFuncSelf(s: string): string { return s; } }
         /** @noSelf */ namespace SelfAnonFuncNSMergedNoSelfNS { export function nsFuncNoSelf(s: string) { return s; } }", "value": "SelfAnonFuncNSMergedNoSelfNS.nsFuncSelf"}): diagnostics 1`] = `"main.ts(4,59): error TSTL: Unable to convert function with a 'this' parameter to function with no 'this'. To fix, wrap in an arrow function, or declare with 'this: void'."`;
 
diff --git a/test/unit/functions/validation/functionPermutations.ts b/test/unit/functions/validation/functionPermutations.ts
index c6c51be91..f6b2672f4 100644
--- a/test/unit/functions/validation/functionPermutations.ts
+++ b/test/unit/functions/validation/functionPermutations.ts
@@ -190,6 +190,12 @@ export const noSelfTestFunctions: TestFunction[] = [
         value: "NoSelfFuncNs.noSelfNsFunc",
         definition: `/** @noSelf */ namespace NoSelfFuncNs { export function noSelfNsFunc(s: string) { return s; } }`,
     },
+    {
+        value: "NoSelfFuncNs.noSelfNsFunc",
+        definition: `namespace NoSelfFuncNs {
+            /** @noSelf */
+            export function noSelfNsFunc(s: string) { return s; } }`,
+    },
     {
         value: "NoSelfFuncNestedNs.NestedNs.noSelfNestedNsFunc",
         definition: `/** @noSelf */ namespace NoSelfFuncNestedNs {
@@ -213,6 +219,14 @@ export const noSelfTestFunctions: TestFunction[] = [
         definition: `/** @noSelf */ class NoSelfMethodClass { noSelfMethod(s: string): string { return s; } }
             const noSelfMethodClass = new NoSelfMethodClass();`,
     },
+    {
+        value: "noSelfMethodClass.noSelfMethod",
+        definition: `class NoSelfMethodClass { 
+                /** @noSelf */
+                noSelfMethod(s: string): string { return s; } 
+            }
+            const noSelfMethodClass = new NoSelfMethodClass();`,
+    },
     {
         value: "NoSelfStaticMethodClass.noSelfStaticMethod",
         definition: `/** @noSelf */ class NoSelfStaticMethodClass {
@@ -255,6 +269,16 @@ export const noSelfTestFunctions: TestFunction[] = [
                 noSelfMethod: function(s: string): string { return s; }
             };`,
     },
+    {
+        value: "noSelfMethodInterface.noSelfMethod",
+        definition: `interface NoSelfMethodInterface { 
+                /** @noSelf */ 
+                noSelfMethod(s: string): string;
+            }
+            const noSelfMethodInterface: NoSelfMethodInterface = {
+                noSelfMethod: function(s: string): string { return s; }
+            };`,
+    },
     {
         value: "noSelfFuncPropInterface.noSelfFuncProp",
         definition: `/** @noSelf */ interface NoSelfFuncPropInterface { noSelfFuncProp(s: string): string; }