Definitely typed - enable typeof namespace conversion (#278)

* definitely typed improvements

* remove enable definitely type on branch push

Author: uittorio

definitelyTypedTests/src/transformer/transformer.ts

@@ -6,10 +6,11 @@ import {
 import * as ts from 'typescript';
 import { GetProgram } from "../../../src/transformer/program/program";
 import { baseTransformer } from '../../../src/transformer/base/base';
-import { GetTypeQueryDescriptor } from '../../../src/transformer/descriptor/typeQuery/typeQuery';
-import { Scope } from '../../../src/transformer/scope/scope';
 import { DefinitelyTypedTransformerLogger } from './logger';
 import * as path from 'path';
+import { GetPropertiesFromSourceFileOrModuleDeclaration } from '../../../src/transformer/descriptor/module/module';
+import { Scope } from '../../../src/transformer/scope/scope';
+import { GetMockPropertiesFromDeclarations } from '../../../src/transformer/descriptor/mock/mockProperties';
 
 const customFunctions: CustomFunction[] = [
     {
@@ -21,6 +22,8 @@ const customFunctions: CustomFunction[] = [
 const transformer = baseTransformer(visitNode, customFunctions);
 export { transformer };
 
+type CompatibleStatement = ts.InterfaceDeclaration | ts.FunctionDeclaration | ts.ClassDeclaration | ts.ModuleDeclaration;
+
 function visitNode(node: ts.CallExpression, declaration: ts.FunctionDeclaration): ts.Node {
     const typeQueryNode: ts.TypeNode = node.typeArguments[0];
 
@@ -42,20 +45,34 @@ function visitNode(node: ts.CallExpression, declaration: ts.FunctionDeclaration)
                 (statement: ts.Statement) => statement.kind === ts.SyntaxKind.InterfaceDeclaration
                     || statement.kind === ts.SyntaxKind.FunctionDeclaration
                     || statement.kind === ts.SyntaxKind.ClassDeclaration
+                    || statement.kind === ts.SyntaxKind.ModuleDeclaration
             );
 
             if (compatibleStatements.length > 0) {
-                return ts.createArrayLiteral(compatibleStatements.map((workingStatement: ts.InterfaceDeclaration | ts.FunctionDeclaration | ts.ClassDeclaration) => {
-                    const nodeToMock: ts.TypeReferenceNode = ts.createTypeReferenceNode(workingStatement.name, []);
+                return ts.createArrayLiteral(compatibleStatements.map(
+                    (workingStatement: CompatibleStatement) => {
+                    const name: ts.Identifier = workingStatement.name as ts.Identifier;
+                    const scope = new Scope();
+
+                    if (ts.isModuleDeclaration(workingStatement)) {
+                        return GetMockPropertiesFromDeclarations(
+                                GetPropertiesFromSourceFileOrModuleDeclaration((workingStatement as any).symbol, scope),
+                                [],
+                                scope
+                            )
+                    }
+
+                    const nodeToMock: ts.TypeReferenceNode = ts.createTypeReferenceNode(name, undefined);
                     return getMock(nodeToMock, node);
-                }));
+
+                }, []));
             }
             DefinitelyTypedTransformerLogger().moduleWithoutValidTypeStatements(moduleName);
 
             return node;
         }
 
-        return GetTypeQueryDescriptor(typeQueryNode, new Scope());
+        return getMock(typeQueryNode, node);
     }
 
     return node;

src/transformer/descriptor/module/module.ts

@@ -27,10 +27,10 @@ function isExternalSource(declaration: ts.Node): declaration is ExternalSource {
 }
 
 function GetPropertiesFromSourceFileOrModuleDeclarationDescriptor(sourceFile: ExternalSource, symbol: ts.Symbol, scope: Scope): ts.Expression {
-  return GetMockPropertiesFromDeclarations(GetPropertiesFromSourceFileOrModuleDeclaration(sourceFile, symbol, scope), [], scope);
+  return GetMockPropertiesFromDeclarations(GetPropertiesFromSourceFileOrModuleDeclaration(symbol, scope), [], scope);
 }
 
-function GetPropertiesFromSourceFileOrModuleDeclaration(sourceFile: ExternalSource, symbol: ts.Symbol, scope: Scope): ts.PropertySignature[] {
+export function GetPropertiesFromSourceFileOrModuleDeclaration(symbol: ts.Symbol, scope: Scope): ts.PropertySignature[] {
   const typeChecker: ts.TypeChecker = TypeChecker();
   const moduleExports: ts.Symbol[] = typeChecker.getExportsOfModule(symbol);
 
@@ -46,7 +46,7 @@ function GetPropertiesFromSourceFileOrModuleDeclaration(sourceFile: ExternalSour
     if (ts.isExportSpecifier(declaration) && ts.isSourceFile(originalDeclaration)) {
       const exportSpecifierSymbol: ts.Symbol = typeChecker.getSymbolAtLocation(declaration.name);
       const exportSpecifierAliasSymbol: ts.Symbol = typeChecker.getAliasedSymbol(exportSpecifierSymbol);
-      const exportSpecifierProperties: ts.PropertySignature[] = GetPropertiesFromSourceFileOrModuleDeclaration(originalDeclaration, exportSpecifierAliasSymbol, scope);
+      const exportSpecifierProperties: ts.PropertySignature[] = GetPropertiesFromSourceFileOrModuleDeclaration(exportSpecifierAliasSymbol, scope);
       const propertyType: ts.TypeNode = ts.createTypeLiteralNode(exportSpecifierProperties);
 
       return TypescriptCreator.createPropertySignature(declaration.name, propertyType);