JS Property assignments create namespaces (hacky)

sandersn · sandersn · commit 2f0e581018b6 · 2017-11-21T15:05:20.000-08:00
This version isn't done yet and I think it still causes failures in the
test suite.
diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
@@ -273,6 +273,9 @@ namespace ts {
                 return getEscapedTextOfIdentifierOrLiteral(<Identifier | LiteralExpression>name);
             }
             switch (node.kind) {
+                case SyntaxKind.Identifier:
+                    // THIS IS WRONG
+                    return (node as any as Identifier).escapedText;
                 case SyntaxKind.Constructor:
                     return InternalSymbolName.Constructor;
                 case SyntaxKind.FunctionType:
@@ -2354,7 +2357,7 @@ namespace ts {
             constructorFunction.parent = classPrototype;
             classPrototype.parent = leftSideOfAssignment;
 
-            bindPropertyAssignment(constructorFunction.escapedText, leftSideOfAssignment, /*isPrototypeProperty*/ true);
+            bindPropertyAssignment(constructorFunction.escapedText, leftSideOfAssignment, /*isPrototypeProperty*/ true, /*isMagic*/ false);
         }
 
         function bindStaticPropertyAssignment(node: BinaryExpression) {
@@ -2377,7 +2380,7 @@ namespace ts {
                     bindExportsPropertyAssignment(node);
                 }
                 else {
-                    bindPropertyAssignment(target.escapedText, leftSideOfAssignment, /*isPrototypeProperty*/ false);
+                    bindPropertyAssignment(target.escapedText, leftSideOfAssignment, /*isPrototypeProperty*/ false, /*isMagic*/ true);
                 }
             }
         }
@@ -2386,14 +2389,22 @@ namespace ts {
             return (container.symbol && container.symbol.exports && container.symbol.exports.get(name)) || (container.locals && container.locals.get(name));
         }
 
-        function bindPropertyAssignment(functionName: __String, propertyAccessExpression: PropertyAccessExpression, isPrototypeProperty: boolean) {
+        function bindPropertyAssignment(functionName: __String, propertyAccessExpression: PropertyAccessExpression, isPrototypeProperty: boolean, isMagic: boolean) {
             let targetSymbol = lookupSymbolForName(functionName);
-
             if (targetSymbol && isDeclarationOfFunctionOrClassExpression(targetSymbol)) {
                 targetSymbol = (targetSymbol.valueDeclaration as VariableDeclaration).initializer.symbol;
             }
-
-            if (!targetSymbol || !(targetSymbol.flags & (SymbolFlags.Function | SymbolFlags.Class))) {
+            if (isMagic && (!targetSymbol || !(targetSymbol.flags & SymbolFlags.Namespace))) {
+                // TODO: Magic may not be required
+                // TODO: Container.locals as symbolTable is probably wrong sometimes (maybe it's sometimes exports?)
+                // TODO: Container.symbol as parent is probably wrong sometimes
+                // TODO: propertyAccessExpression.expression isn't a Declaration
+                targetSymbol = declareSymbol(container.locals, container.symbol, propertyAccessExpression.expression as any as Declaration, SymbolFlags.NamespaceModule, SymbolFlags.NamespaceModuleExcludes);
+            }
+            if (targetSymbol && isDeclarationOfFunctionOrClassExpression(targetSymbol)) {
+                targetSymbol = (targetSymbol.valueDeclaration as VariableDeclaration).initializer.symbol;
+            }
+            if (!isMagic && (!targetSymbol || !(targetSymbol.flags & (SymbolFlags.Function | SymbolFlags.Class)))) {
                 return;
             }
 
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -1381,7 +1381,8 @@ namespace ts {
         function checkAndReportErrorForUsingNamespaceModuleAsValue(errorLocation: Node, name: __String, meaning: SymbolFlags): boolean {
             if (meaning & (SymbolFlags.Value & ~SymbolFlags.NamespaceModule & ~SymbolFlags.Type)) {
                 const symbol = resolveSymbol(resolveName(errorLocation, name, SymbolFlags.NamespaceModule & ~SymbolFlags.Value, /*nameNotFoundMessage*/undefined, /*nameArg*/ undefined, /*isUse*/ false));
-                if (symbol) {
+                // TODO: WRONG
+                if (symbol && !isInJavaScriptFile(errorLocation)) {
                     error(errorLocation, Diagnostics.Cannot_use_namespace_0_as_a_value, unescapeLeadingUnderscores(name));
                     return true;
                 }
@@ -1734,15 +1735,7 @@ namespace ts {
                     return undefined;
                 }
                 const right = name.kind === SyntaxKind.QualifiedName ? name.right : name.name;
-                let namespace = resolveEntityName(left, SymbolFlags.Namespace, /*ignoreErrors*/ true, /*dontResolveAlias*/ false, location);
-                if (!namespace && name.parent && isJSDocTypeReference(name.parent as TypeReferenceType)) {
-                    // jsdoc type references may be values
-                    namespace = resolveEntityName(left, SymbolFlags.Value, ignoreErrors, /*dontResolveAlias*/ false, location);
-                }
-                else if (!ignoreErrors) {
-                    // run again for error reporting purposes
-                    resolveEntityName(left, SymbolFlags.Namespace, /*ignoreErrors*/ false, /*dontResolveAlias*/ false, location);
-                }
+                let namespace = resolveEntityName(left, SymbolFlags.Namespace, ignoreErrors, /*dontResolveAlias*/ false, location);
                 if (!namespace || nodeIsMissing(right)) {
                     return undefined;
                 }

Original file line number	Diff line number	Diff line change
`@@ -273,6 +273,9 @@ namespace ts {`
`273`	`273`	`return getEscapedTextOfIdentifierOrLiteral(<Identifier \| LiteralExpression>name);`
`274`	`274`	`}`
`275`	`275`	`switch (node.kind) {`
	`276`	`+ case SyntaxKind.Identifier:`
	`277`	`+ // THIS IS WRONG`
	`278`	`+ return (node as any as Identifier).escapedText;`
`276`	`279`	`case SyntaxKind.Constructor:`
`277`	`280`	`return InternalSymbolName.Constructor;`
`278`	`281`	`case SyntaxKind.FunctionType:`
`@@ -2354,7 +2357,7 @@ namespace ts {`
`2354`	`2357`	`constructorFunction.parent = classPrototype;`
`2355`	`2358`	`classPrototype.parent = leftSideOfAssignment;`
`2356`	`2359`
`2357`		`- bindPropertyAssignment(constructorFunction.escapedText, leftSideOfAssignment, /isPrototypeProperty/ true);`
	`2360`	`+ bindPropertyAssignment(constructorFunction.escapedText, leftSideOfAssignment, /isPrototypeProperty/ true, /isMagic/ false);`
`2358`	`2361`	`}`
`2359`	`2362`
`2360`	`2363`	`function bindStaticPropertyAssignment(node: BinaryExpression) {`
`@@ -2377,7 +2380,7 @@ namespace ts {`
`2377`	`2380`	`bindExportsPropertyAssignment(node);`
`2378`	`2381`	`}`
`2379`	`2382`	`else {`
`2380`		`- bindPropertyAssignment(target.escapedText, leftSideOfAssignment, /isPrototypeProperty/ false);`
	`2383`	`+ bindPropertyAssignment(target.escapedText, leftSideOfAssignment, /isPrototypeProperty/ false, /isMagic/ true);`
`2381`	`2384`	`}`
`2382`	`2385`	`}`
`2383`	`2386`	`}`
`@@ -2386,14 +2389,22 @@ namespace ts {`
`2386`	`2389`	`return (container.symbol && container.symbol.exports && container.symbol.exports.get(name)) \|\| (container.locals && container.locals.get(name));`
`2387`	`2390`	`}`
`2388`	`2391`
`2389`		`- function bindPropertyAssignment(functionName: __String, propertyAccessExpression: PropertyAccessExpression, isPrototypeProperty: boolean) {`
	`2392`	`+ function bindPropertyAssignment(functionName: __String, propertyAccessExpression: PropertyAccessExpression, isPrototypeProperty: boolean, isMagic: boolean) {`
`2390`	`2393`	`let targetSymbol = lookupSymbolForName(functionName);`
`2391`		`-`
`2392`	`2394`	`if (targetSymbol && isDeclarationOfFunctionOrClassExpression(targetSymbol)) {`
`2393`	`2395`	`targetSymbol = (targetSymbol.valueDeclaration as VariableDeclaration).initializer.symbol;`
`2394`	`2396`	`}`
`2395`		`-`
`2396`		`- if (!targetSymbol \|\| !(targetSymbol.flags & (SymbolFlags.Function \| SymbolFlags.Class))) {`
	`2397`	`+ if (isMagic && (!targetSymbol \|\| !(targetSymbol.flags & SymbolFlags.Namespace))) {`
	`2398`	`+ // TODO: Magic may not be required`
	`2399`	`+ // TODO: Container.locals as symbolTable is probably wrong sometimes (maybe it's sometimes exports?)`
	`2400`	`+ // TODO: Container.symbol as parent is probably wrong sometimes`
	`2401`	`+ // TODO: propertyAccessExpression.expression isn't a Declaration`
	`2402`	`+ targetSymbol = declareSymbol(container.locals, container.symbol, propertyAccessExpression.expression as any as Declaration, SymbolFlags.NamespaceModule, SymbolFlags.NamespaceModuleExcludes);`
	`2403`	`+ }`
	`2404`	`+ if (targetSymbol && isDeclarationOfFunctionOrClassExpression(targetSymbol)) {`
	`2405`	`+ targetSymbol = (targetSymbol.valueDeclaration as VariableDeclaration).initializer.symbol;`
	`2406`	`+ }`
	`2407`	`+ if (!isMagic && (!targetSymbol \|\| !(targetSymbol.flags & (SymbolFlags.Function \| SymbolFlags.Class)))) {`
`2397`	`2408`	`return;`
`2398`	`2409`	`}`
`2399`	`2410`