This function types

src/compiler/commandLineParser.ts

@@ -122,6 +122,11 @@ namespace ts {
             type: "boolean",
             description: Diagnostics.Raise_error_on_expressions_and_declarations_with_an_implied_any_type,
         },
+        {
+            name: "noImplicitThis",
+            type: "boolean",
+            description: Diagnostics.Raise_error_on_this_expressions_with_an_implied_any_type,
+        },
         {
             name: "noLib",
             type: "boolean",

src/compiler/diagnosticMessages.json

@@ -1879,6 +1879,34 @@
         "category": "Error",
         "code": 2678
     },
+    "A function that is called with the 'new' keyword cannot have a 'this' type that is 'void'.": {
+        "category": "Error",
+        "code": 2679
+    },
+    "A 'this' parameter must be the first parameter.": {
+        "category": "Error",
+        "code": 2680
+    },
+    "A constructor cannot have a 'this' parameter.": {
+        "category": "Error",
+        "code": 2681
+    },
+    "A setter cannot have a 'this' parameter.": {
+        "category": "Error",
+        "code": 2682
+    },
+    "'this' implicitly has type 'any' because it does not have a type annotation.": {
+        "category": "Error",
+        "code": 2683
+    },
+    "The 'this' context of type '{0}' is not assignable to method's 'this' of type '{1}'.": {
+        "category": "Error",
+        "code": 2684
+    },
+    "The 'this' types of each signature are incompatible.": {
+        "category": "Error",
+        "code": 2685
+    },
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",
         "code": 4000
@@ -2632,7 +2660,10 @@
         "category": "Error",
         "code": 6114
     },
-
+    "Raise error on 'this' expressions with an implied 'any' type.": {
+        "category": "Message",
+        "code": 6115
+    },
     "Variable '{0}' implicitly has an '{1}' type.": {
         "category": "Error",
         "code": 7005

src/compiler/emitter.ts

@@ -4630,8 +4630,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 write("(");
                 if (node) {
                     const parameters = node.parameters;
+                    const skipCount = node.parameters.length && (<Identifier>node.parameters[0].name).text === "this" ? 1 : 0;
                     const omitCount = languageVersion < ScriptTarget.ES6 && hasRestParameter(node) ? 1 : 0;
-                    emitList(parameters, 0, parameters.length - omitCount, /*multiLine*/ false, /*trailingComma*/ false);
+                    emitList(parameters, skipCount, parameters.length - omitCount - skipCount, /*multiLine*/ false, /*trailingComma*/ false);
                 }
                 write(")");
                 decreaseIndent();

src/compiler/parser.ts

@@ -2010,7 +2010,7 @@ namespace ts {
         }
 
         function isStartOfParameter(): boolean {
-            return token === SyntaxKind.DotDotDotToken || isIdentifierOrPattern() || isModifierKind(token) || token === SyntaxKind.AtToken;
+            return token === SyntaxKind.DotDotDotToken || isIdentifierOrPattern() || isModifierKind(token) || token === SyntaxKind.AtToken || token === SyntaxKind.ThisKeyword;
         }
 
         function setModifiers(node: Node, modifiers: ModifiersArray) {
@@ -2022,15 +2022,19 @@ namespace ts {
 
         function parseParameter(): ParameterDeclaration {
             const node = <ParameterDeclaration>createNode(SyntaxKind.Parameter);
+            if (token === SyntaxKind.ThisKeyword) {
+                node.name = createIdentifier(/*isIdentifier*/true, undefined);
+                node.type = parseParameterType();
+                return finishNode(node);
+            }
+
             node.decorators = parseDecorators();
             setModifiers(node, parseModifiers());
             node.dotDotDotToken = parseOptionalToken(SyntaxKind.DotDotDotToken);
 
             // FormalParameter [Yield,Await]:
             //      BindingElement[?Yield,?Await]
-
             node.name = parseIdentifierOrPattern();
-
             if (getFullWidth(node.name) === 0 && node.flags === 0 && isModifierKind(token)) {
                 // in cases like
                 // 'use strict'
@@ -2068,11 +2072,11 @@ namespace ts {
         }
 
         function fillSignature(
-                returnToken: SyntaxKind,
-                yieldContext: boolean,
-                awaitContext: boolean,
-                requireCompleteParameterList: boolean,
-                signature: SignatureDeclaration): void {
+            returnToken: SyntaxKind,
+            yieldContext: boolean,
+            awaitContext: boolean,
+            requireCompleteParameterList: boolean,
+            signature: SignatureDeclaration): void {
 
             const returnTokenRequired = returnToken === SyntaxKind.EqualsGreaterThanToken;
             signature.typeParameters = parseTypeParameters();
@@ -2473,7 +2477,7 @@ namespace ts {
                 // Skip modifiers
                 parseModifiers();
             }
-            if (isIdentifier()) {
+            if (isIdentifier() || token === SyntaxKind.ThisKeyword) {
                 nextToken();
                 return true;
             }

src/compiler/types.ts

@@ -1778,7 +1778,7 @@ namespace ts {
         buildTypeParameterDisplay(tp: TypeParameter, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
         buildTypePredicateDisplay(predicate: TypePredicate, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
         buildTypeParameterDisplayFromSymbol(symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
-        buildDisplayForParametersAndDelimiters(parameters: Symbol[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
+        buildDisplayForParametersAndDelimiters(thisType: Type, parameters: Symbol[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
         buildDisplayForTypeParametersAndDelimiters(typeParameters: TypeParameter[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
         buildReturnTypeDisplay(signature: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
     }
@@ -2280,6 +2280,7 @@ namespace ts {
         declaration: SignatureDeclaration;  // Originating declaration
         typeParameters: TypeParameter[];    // Type parameters (undefined if non-generic)
         parameters: Symbol[];               // Parameters
+        thisType?: Type;                    // type of this-type
         /* @internal */
         resolvedReturnType: Type;           // Resolved return type
         /* @internal */
@@ -2424,6 +2425,7 @@ namespace ts {
         noEmitOnError?: boolean;
         noErrorTruncation?: boolean;
         noImplicitAny?: boolean;
+        noImplicitThis?: boolean;
         noLib?: boolean;
         noResolve?: boolean;
         out?: string;

src/harness/loggedIO.ts

@@ -237,8 +237,8 @@ namespace Playback {
                     ), path));
 
         wrapper.writeFile = recordReplay(wrapper.writeFile, underlying)(
-            (path, contents) => callAndRecord(underlying.writeFile(path, contents), recordLog.filesWritten, { path, contents, bom: false }),
-            (path, contents) => noOpReplay("writeFile"));
+            (path: string, contents: string) => callAndRecord(underlying.writeFile(path, contents), recordLog.filesWritten, { path, contents, bom: false }),
+            (path: string, contents: string) => noOpReplay("writeFile"));
 
         wrapper.exit = (exitCode) => {
             if (recordLog !== undefined) {

src/lib/es5.d.ts

@@ -215,22 +215,25 @@ interface Function {
       * @param thisArg The object to be used as the this object.
       * @param argArray A set of arguments to be passed to the function.
       */
-    apply(thisArg: any, argArray?: any): any;
+    apply<T, U>(this: (this: T, ...argArray: any[]) => U, thisArg: T, argArray?: any): U;
+    apply(this: Function, thisArg: any, argArray?: any): any;
 
     /**
       * Calls a method of an object, substituting another object for the current object.
       * @param thisArg The object to be used as the current object.
       * @param argArray A list of arguments to be passed to the method.
       */
-    call(thisArg: any, ...argArray: any[]): any;
+    call<T, U>(this: (this: T, ...argArray: any[]) => U, thisArg: T, ...argArray: any[]): U;
+    call(this: Function, thisArg: any, ...argArray: any[]): any;
 
     /**
       * For a given function, creates a bound function that has the same body as the original function. 
       * The this object of the bound function is associated with the specified object, and has the specified initial parameters.
       * @param thisArg An object to which the this keyword can refer inside the new function.
       * @param argArray A list of arguments to be passed to the new function.
       */
-    bind(thisArg: any, ...argArray: any[]): any;
+    bind<T, U>(this: (this: T, ...argArray: any[]) => U, thisArg: T, ...argArray: any[]): (this: void, ...argArray: any[]) => U;
+    bind(this: Function, thisArg: any, ...argArray: any[]): any;
 
     prototype: any;
     readonly length: number;

src/services/services.ts

@@ -741,6 +741,7 @@ namespace ts {
         declaration: SignatureDeclaration;
         typeParameters: TypeParameter[];
         parameters: Symbol[];
+        thisType: Type;
         resolvedReturnType: Type;
         minArgumentCount: number;
         hasRestParameter: boolean;
@@ -4109,6 +4110,9 @@ namespace ts {
             if (typeChecker.isArgumentsSymbol(symbol)) {
                 return ScriptElementKind.localVariableElement;
             }
+            if (location.kind === SyntaxKind.ThisKeyword && isExpression(location)) {
+                return ScriptElementKind.parameterElement;
+            }
             if (flags & SymbolFlags.Variable) {
                 if (isFirstDeclarationOfSymbolParameter(symbol)) {
                     return ScriptElementKind.parameterElement;
@@ -4171,6 +4175,7 @@ namespace ts {
             const symbolFlags = symbol.flags;
             let symbolKind = getSymbolKindOfConstructorPropertyMethodAccessorFunctionOrVar(symbol, symbolFlags, location);
             let hasAddedSymbolInfo: boolean;
+            const isThisExpression: boolean = location.kind === SyntaxKind.ThisKeyword && isExpression(location);
             let type: Type;
 
             // Class at constructor site need to be shown as constructor apart from property,method, vars
@@ -4181,7 +4186,7 @@ namespace ts {
                 }
 
                 let signature: Signature;
-                type = typeChecker.getTypeOfSymbolAtLocation(symbol, location);
+                type = isThisExpression ? typeChecker.getTypeAtLocation(location) : typeChecker.getTypeOfSymbolAtLocation(symbol, location);
                 if (type) {
                     if (location.parent && location.parent.kind === SyntaxKind.PropertyAccessExpression) {
                         const right = (<PropertyAccessExpression>location.parent).name;
@@ -4292,7 +4297,7 @@ namespace ts {
                     }
                 }
             }
-            if (symbolFlags & SymbolFlags.Class && !hasAddedSymbolInfo) {
+            if (symbolFlags & SymbolFlags.Class && !hasAddedSymbolInfo && !isThisExpression) {
                 if (getDeclarationOfKind(symbol, SyntaxKind.ClassExpression)) {
                     // Special case for class expressions because we would like to indicate that
                     // the class name is local to the class body (similar to function expression)
@@ -4434,11 +4439,19 @@ namespace ts {
             if (!hasAddedSymbolInfo) {
                 if (symbolKind !== ScriptElementKind.unknown) {
                     if (type) {
-                        addPrefixForAnyFunctionOrVar(symbol, symbolKind);
+                        if (isThisExpression) {
+                            addNewLineIfDisplayPartsExist();
+                            displayParts.push(keywordPart(SyntaxKind.ThisKeyword));
+                        }
+                        else {
+                            addPrefixForAnyFunctionOrVar(symbol, symbolKind);
+                        }
+
                         // For properties, variables and local vars: show the type
                         if (symbolKind === ScriptElementKind.memberVariableElement ||
                             symbolFlags & SymbolFlags.Variable ||
-                            symbolKind === ScriptElementKind.localVariableElement) {
+                            symbolKind === ScriptElementKind.localVariableElement ||
+                            isThisExpression) {
                             displayParts.push(punctuationPart(SyntaxKind.ColonToken));
                             displayParts.push(spacePart());
                             // If the type is type parameter, format it specially

src/services/signatureHelp.ts

@@ -559,7 +559,7 @@ namespace ts.SignatureHelp {
                     signatureHelpParameters = typeParameters && typeParameters.length > 0 ? map(typeParameters, createSignatureHelpParameterForTypeParameter) : emptyArray;
                     suffixDisplayParts.push(punctuationPart(SyntaxKind.GreaterThanToken));
                     let parameterParts = mapToDisplayParts(writer =>
-                        typeChecker.getSymbolDisplayBuilder().buildDisplayForParametersAndDelimiters(candidateSignature.parameters, writer, invocation));
+                        typeChecker.getSymbolDisplayBuilder().buildDisplayForParametersAndDelimiters(candidateSignature.thisType, candidateSignature.parameters, writer, invocation));
                     addRange(suffixDisplayParts, parameterParts);
                 }
                 else {

tests/baselines/reference/assignmentToObjectAndFunction.errors.txt

@@ -5,7 +5,7 @@ tests/cases/compiler/assignmentToObjectAndFunction.ts(8,5): error TS2322: Type '
   Property 'apply' is missing in type '{}'.
 tests/cases/compiler/assignmentToObjectAndFunction.ts(29,5): error TS2322: Type 'typeof bad' is not assignable to type 'Function'.
   Types of property 'apply' are incompatible.
-    Type 'number' is not assignable to type '(thisArg: any, argArray?: any) => any'.
+    Type 'number' is not assignable to type '{ <T, U>(this: (this: T, ...argArray: any[]) => U, thisArg: T, argArray?: any): U; (this: Function, thisArg: any, argArray?: any): any; }'.
 
 
 ==== tests/cases/compiler/assignmentToObjectAndFunction.ts (3 errors) ====
@@ -48,4 +48,4 @@ tests/cases/compiler/assignmentToObjectAndFunction.ts(29,5): error TS2322: Type
         ~~~~~~~~~~
 !!! error TS2322: Type 'typeof bad' is not assignable to type 'Function'.
 !!! error TS2322:   Types of property 'apply' are incompatible.
-!!! error TS2322:     Type 'number' is not assignable to type '(thisArg: any, argArray?: any) => any'.
+!!! error TS2322:     Type 'number' is not assignable to type '{ <T, U>(this: (this: T, ...argArray: any[]) => U, thisArg: T, argArray?: any): U; (this: Function, thisArg: any, argArray?: any): any; }'.

tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.symbols

@@ -10,9 +10,9 @@ class C {
 
       var fn = async () => await other.apply(this, arguments);      
 >fn : Symbol(fn, Decl(asyncArrowFunctionCapturesArguments_es6.ts, 3, 9))
->other.apply : Symbol(Function.apply, Decl(lib.es5.d.ts, --, --))
+>other.apply : Symbol(Function.apply, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >other : Symbol(other, Decl(asyncArrowFunctionCapturesArguments_es6.ts, 1, 13))
->apply : Symbol(Function.apply, Decl(lib.es5.d.ts, --, --))
+>apply : Symbol(Function.apply, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >this : Symbol(C, Decl(asyncArrowFunctionCapturesArguments_es6.ts, 0, 0))
 >arguments : Symbol(arguments)
    }

tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.types

@@ -9,13 +9,13 @@ class C {
 >other : () => void
 
       var fn = async () => await other.apply(this, arguments);      
->fn : () => Promise<any>
->async () => await other.apply(this, arguments) : () => Promise<any>
->await other.apply(this, arguments) : any
->other.apply(this, arguments) : any
->other.apply : (thisArg: any, argArray?: any) => any
+>fn : () => Promise<void>
+>async () => await other.apply(this, arguments) : () => Promise<void>
+>await other.apply(this, arguments) : void
+>other.apply(this, arguments) : void
+>other.apply : { <T, U>(this: (this: T, ...argArray: any[]) => U, thisArg: T, argArray?: any): U; (this: Function, thisArg: any, argArray?: any): any; }
 >other : () => void
->apply : (thisArg: any, argArray?: any) => any
+>apply : { <T, U>(this: (this: T, ...argArray: any[]) => U, thisArg: T, argArray?: any): U; (this: Function, thisArg: any, argArray?: any): any; }
 >this : this
 >arguments : IArguments
    }

tests/baselines/reference/commentsOnObjectLiteral3.symbols

@@ -21,13 +21,20 @@ var v = {
 >a : Symbol(a, Decl(commentsOnObjectLiteral3.ts, 8, 13), Decl(commentsOnObjectLiteral3.ts, 12, 18))
 
   return this.prop;
+>this.prop : Symbol(prop, Decl(commentsOnObjectLiteral3.ts, 1, 9))
+>this : Symbol(, Decl(commentsOnObjectLiteral3.ts, 1, 7))
+>prop : Symbol(prop, Decl(commentsOnObjectLiteral3.ts, 1, 9))
+
  } /*trailing 1*/,
  //setter
  set a(value) {
 >a : Symbol(a, Decl(commentsOnObjectLiteral3.ts, 8, 13), Decl(commentsOnObjectLiteral3.ts, 12, 18))
 >value : Symbol(value, Decl(commentsOnObjectLiteral3.ts, 14, 7))
 
   this.prop = value;
+>this.prop : Symbol(prop, Decl(commentsOnObjectLiteral3.ts, 1, 9))
+>this : Symbol(, Decl(commentsOnObjectLiteral3.ts, 1, 7))
+>prop : Symbol(prop, Decl(commentsOnObjectLiteral3.ts, 1, 9))
 >value : Symbol(value, Decl(commentsOnObjectLiteral3.ts, 14, 7))
 
  } // trailing 2

tests/baselines/reference/commentsOnObjectLiteral3.types

@@ -24,9 +24,9 @@ var v = {
 >a : any
 
   return this.prop;
->this.prop : any
->this : any
->prop : any
+>this.prop : number
+>this : { prop: number; func: () => void; func1(): void; a: any; }
+>prop : number
 
  } /*trailing 1*/,
  //setter
@@ -36,9 +36,9 @@ var v = {
 
   this.prop = value;
 >this.prop = value : any
->this.prop : any
->this : any
->prop : any
+>this.prop : number
+>this : { prop: number; func: () => void; func1(): void; a: any; }
+>prop : number
 >value : any
 
  } // trailing 2

tests/baselines/reference/commentsOnObjectLiteral4.js

@@ -5,16 +5,17 @@ var v = {
   * @type {number}
   */
  get bar(): number {
-  return this._bar;
+  return 12;
  }
-}
+}
+
 
 //// [commentsOnObjectLiteral4.js]
 var v = {
     /**
      * @type {number}
      */
     get bar() {
-        return this._bar;
+        return 12;
     }
 };

tests/baselines/reference/commentsOnObjectLiteral4.symbols

@@ -9,6 +9,7 @@ var v = {
  get bar(): number {
 >bar : Symbol(bar, Decl(commentsOnObjectLiteral4.ts, 1, 9))
 
-  return this._bar;
+  return 12;
  }
 }
+