Mark js-assignment functions' symbols as methods

src/compiler/binder.ts

@@ -2473,8 +2473,10 @@ namespace ts {
                 (symbol.exports || (symbol.exports = createSymbolTable()));
 
             // Declare the method/property
-            const symbolFlags = SymbolFlags.Property | (isToplevelNamespaceableInitializer ? SymbolFlags.JSContainer : 0);
-            const symbolExcludes = SymbolFlags.PropertyExcludes & ~(isToplevelNamespaceableInitializer ? SymbolFlags.JSContainer : 0);
+            const jsContainerFlag = isToplevelNamespaceableInitializer ? SymbolFlags.JSContainer : 0;
+            const isMethod = isFunctionLikeDeclaration(getAssignedJavascriptInitializer(propertyAccess));
+            const symbolFlags = (isMethod ? SymbolFlags.Method : SymbolFlags.Property) | jsContainerFlag;
+            const symbolExcludes = (isMethod ? SymbolFlags.MethodExcludes : SymbolFlags.PropertyExcludes) & ~jsContainerFlag;
             declareSymbol(symbolTable, symbol, propertyAccess, symbolFlags, symbolExcludes);
         }
 

src/compiler/checker.ts

@@ -4679,6 +4679,10 @@ namespace ts {
                 if (symbol.flags & SymbolFlags.Module && isShorthandAmbientModuleSymbol(symbol)) {
                     links.type = anyType;
                 }
+                else if (symbol.valueDeclaration.kind === SyntaxKind.BinaryExpression ||
+                         symbol.valueDeclaration.kind === SyntaxKind.PropertyAccessExpression && symbol.valueDeclaration.parent.kind === SyntaxKind.BinaryExpression) {
+                    links.type = getWidenedTypeFromJSSpecialPropertyDeclarations(symbol);
+                }
                 else {
                     const type = createObjectType(ObjectFlags.Anonymous, symbol);
                     if (symbol.flags & SymbolFlags.Class) {
@@ -6935,7 +6939,8 @@ namespace ts {
             if (!symbol) return emptyArray;
             const result: Signature[] = [];
             for (let i = 0; i < symbol.declarations.length; i++) {
-                const node = symbol.declarations[i];
+                const decl = symbol.declarations[i];
+                const node = isPropertyAccessExpression(decl) ? getAssignedJavascriptInitializer(decl) : decl;
                 if (!isFunctionLike(node)) continue;
                 // Don't include signature if node is the implementation of an overloaded function. A node is considered
                 // an implementation node if it has a body and the previous node is of the same kind and immediately
@@ -16221,9 +16226,7 @@ namespace ts {
         }
 
         function isMethodLike(symbol: Symbol) {
-            return !!(symbol.flags & SymbolFlags.Method ||
-                      getCheckFlags(symbol) & CheckFlags.SyntheticMethod ||
-                      isInJavaScriptFile(symbol.valueDeclaration) && isFunctionLikeDeclaration(getAssignedJavascriptInitializer(symbol.valueDeclaration)));
+            return !!(symbol.flags & SymbolFlags.Method || getCheckFlags(symbol) & CheckFlags.SyntheticMethod);
         }
 
         /**

src/services/codefixes/convertFunctionToEs6Class.ts

@@ -99,8 +99,8 @@ namespace ts.codefix {
             }
 
             function createClassElement(symbol: Symbol, modifiers: Modifier[]): ClassElement {
-                // both properties and methods are bound as property symbols
-                if (!(symbol.flags & SymbolFlags.Property)) {
+                // Right now the only thing we can convert are function expressions, which are marked as methods
+                if (!(symbol.flags & SymbolFlags.Method)) {
                     return;
                 }
 

tests/baselines/reference/constructorFunctions2.types

@@ -40,23 +40,23 @@ B.prototype.m = function() { this.x = 2; }
 >function() { this.x = 2; } : () => void
 >this.x = 2 : 2
 >this.x : number
->this : { id: number; m: () => void; x: number; }
+>this : { id: number; m(): void; x: number; }
 >x : number
 >2 : 2
 
 const b = new B();
->b : { id: number; m: () => void; x: number; }
->new B() : { id: number; m: () => void; x: number; }
+>b : { id: number; m(): void; x: number; }
+>new B() : { id: number; m(): void; x: number; }
 >B : () => void
 
 b.id;
 >b.id : number
->b : { id: number; m: () => void; x: number; }
+>b : { id: number; m(): void; x: number; }
 >id : number
 
 b.x;
 >b.x : number
->b : { id: number; m: () => void; x: number; }
+>b : { id: number; m(): void; x: number; }
 >x : number
 
 === tests/cases/conformance/salsa/other.js ===

tests/baselines/reference/constructorFunctionsStrict.types

@@ -23,27 +23,27 @@ C.prototype.m = function() {
     this.y = 12
 >this.y = 12 : 12
 >this.y : number | undefined
->this : { x: number; m: () => void; y: number | undefined; }
+>this : { x: number; m(): void; y: number | undefined; }
 >y : number | undefined
 >12 : 12
 }
 var c = new C(1)
->c : { x: number; m: () => void; y: number | undefined; }
->new C(1) : { x: number; m: () => void; y: number | undefined; }
+>c : { x: number; m(): void; y: number | undefined; }
+>new C(1) : { x: number; m(): void; y: number | undefined; }
 >C : (x: number) => void
 >1 : 1
 
 c.x = undefined // should error
 >c.x = undefined : undefined
 >c.x : number
->c : { x: number; m: () => void; y: number | undefined; }
+>c : { x: number; m(): void; y: number | undefined; }
 >x : number
 >undefined : undefined
 
 c.y = undefined // ok
 >c.y = undefined : undefined
 >c.y : number | undefined
->c : { x: number; m: () => void; y: number | undefined; }
+>c : { x: number; m(): void; y: number | undefined; }
 >y : number | undefined
 >undefined : undefined
 

tests/baselines/reference/inferringClassMembersFromAssignments2.types

@@ -11,7 +11,7 @@ OOOrder.prototype.m = function () {
     this.p = 1
 >this.p = 1 : 1
 >this.p : number
->this : { x: number; m: () => void; p: number; }
+>this : { x: number; m(): void; p: number; }
 >p : number
 >1 : 1
 }

tests/baselines/reference/jsContainerMergeTsDeclaration.types

@@ -1,20 +1,20 @@
 === tests/cases/conformance/salsa/a.js ===
 var /*1*/x = function foo() {
->x : { (): void; a: () => void; }
->function foo() {} : { (): void; a: () => void; }
->foo : { (): void; a: () => void; }
+>x : { (): void; a(): void; }
+>function foo() {} : { (): void; a(): void; }
+>foo : { (): void; a(): void; }
 }
 x.a = function bar() {
 >x.a = function bar() {} : () => void
 >x.a : () => void
->x : { (): void; a: () => void; }
+>x : { (): void; a(): void; }
 >a : () => void
 >function bar() {} : () => void
 >bar : () => void
 }
 === tests/cases/conformance/salsa/b.ts ===
 var x = function () {
->x : { (): void; a: () => void; }
+>x : { (): void; a(): void; }
 >function () {    return 1;}() : number
 >function () {    return 1;} : () => number