fix for more scenarios.

Author: Mathias Lorenzen

package-lock.json

@@ -23,7 +23,7 @@
     "jasmine": "^2.6.0"
   },
   "dependencies": {
-    "@fluffy-spoon/javascript.csharp-parser": "1.0.108",
+    "@fluffy-spoon/javascript.csharp-parser": "1.0.115",
     "npm": "^5.8.0",
     "typescript": "^2.8.1"
   }

package.json

@@ -0,0 +1,31 @@
+var fs = require('fs');
+
+import { Emitter, EmitOptions } from '../src/Emitter';
+import { Logger } from '../src/Logger';
+import { FileEmitOptions } from '../src/FileEmitter';
+import { TypeScriptEmitter } from '../src/TypeScriptEmitter';
+import { TypeEmitter, TypeEmitOptions } from '../src/Index';
+
+import { CSharpFile, CSharpClass, CSharpMethod, CSharpType, TypeParser } from '@fluffy-spoon/javascript.csharp-parser';
+
+import typescript = require("typescript");
+
+describe("TypeEmitter", function () {
+	it("should be able to handle type mapping", function (done) {
+		var typeEmitter = new TypeEmitter(new TypeScriptEmitter());
+		var typeParser = new TypeParser();
+
+		var csharpType = typeParser.parseType("Task<IEnumerable<string>>");
+		expect(csharpType.name).toBe("Task<>");
+		expect(csharpType.isGeneric).toBe(true);
+		expect(csharpType.genericParameters[0].name).toBe("IEnumerable<>");
+		expect(csharpType.genericParameters[0].isGeneric).toBe(true);
+		expect(csharpType.genericParameters[0].genericParameters[0].name).toBe("string");
+		expect(csharpType.genericParameters[0].genericParameters[0].isGeneric).toBe(false);
+
+		expect(typeEmitter.convertTypeToTypeScript(csharpType)).toBe("Promise<Array<string>>");
+
+		done();
+	});
+
+});

spec/TypeEmitterSpec.ts

@@ -6,6 +6,8 @@ public void MyMethod(string foo, params string[] bar) { }
 
 	public void MyNullParameterMethod(string foo = null) { }
 
+	public Task<IEnumerable<string>> TaskArrayMethod() { }
+
 	public string foo;
 }
 

spec/cases/Class.case.cs

@@ -3,6 +3,7 @@
 	myProperty: string;
 	myMethod(foo: string, ...bar: Array<string>): void;
 	myNullParameterMethod(foo?: string): void;
+	taskArrayMethod(): Promise<Array<string>>;
 }
 
 declare interface MainClass<Foo> {

spec/cases/Class.expected.d.ts

@@ -239,7 +239,9 @@ function LegacyAdapter(contents: any, options: any) {
 
 		if (options.customTypeTranslations) {
 			emitOptions.defaults.typeEmitOptions = <TypeEmitOptions>{
-				mapper: (type, suggested) => options.customTypeTranslations[type.name] || suggested
+				mapper: (type, suggested) => {
+					return options.customTypeTranslations[type.name] || suggested
+				}
 			};
 		}
 

spec/legacy/adapters/legacyAdapter.ts

@@ -141,7 +141,7 @@ export class ClassEmitter {
 				.filter(x => !!x);
 
 			var genericParameters = new Array<ts.TypeParameterDeclaration>();
-			if (classObject.genericParameters)
+			if (classObject.isGeneric)
 				genericParameters = genericParameters.concat(classObject
 					.genericParameters
 					.map(x => this

src/ClassEmitter.ts

@@ -115,7 +115,7 @@ export class InterfaceEmitter {
 			.filter(x => !!x);
 
 		var genericParameters = new Array<ts.TypeParameterDeclaration>();
-		if (interfaceObject.genericParameters)
+		if (interfaceObject.isGeneric)
 			genericParameters = genericParameters.concat(interfaceObject
 				.genericParameters
 				.map(x => this

src/InterfaceEmitter.ts

@@ -66,15 +66,11 @@ export class TypeEmitter {
 		this.typeScriptEmitter.emitTypeScriptNode(node);
 	}
 
-	emitGenericParameters(genericParameters: CSharpType[], options: TypeEmitOptions) {
-		this.typeScriptEmitter.write(this.generateGenericParametersString(genericParameters, options));
-	}
-
 	createTypeScriptExpressionWithTypeArguments(type: CSharpType, options: TypeEmitOptions) {
 		var typeName = this.getNonGenericMatchingTypeMappingAsString(type, options);
 		return ts.createExpressionWithTypeArguments(
 			this.createTypeScriptTypeReferenceNodes(
-				type.genericParameters || [],
+				type.genericParameters,
 				options),
 			ts.createIdentifier(typeName));
 	}
@@ -118,7 +114,7 @@ export class TypeEmitter {
 	createTypeScriptTypeReferenceNodes(types: CSharpType[], options: TypeEmitOptions) {
 		var nodes = new Array<ts.TypeReferenceNode>();
 		if(!types)
-			return nodes;
+			return [];
 
 		for(var type of types) {
 			var node = ts.createTypeReferenceNode(
@@ -151,7 +147,7 @@ export class TypeEmitter {
 				continue;
 
 			let mapping = this.defaultTypeMap[mappingKey];
-			if (mappingKeyType.genericParameters) {
+			if (mappingKeyType.isGeneric) {
 				mapping = this.substituteMultipleGenericReferencesIntoMapping(
 					mappingKeyType,
 					type,
@@ -163,7 +159,7 @@ export class TypeEmitter {
 		}
 
 		let mappedValue = this.getNonGenericTypeName(type);
-		if(type.genericParameters) {
+		if(type.isGeneric) {
 			mappedValue += this.generateGenericParametersString(type.genericParameters, options);
 		}
 
@@ -175,7 +171,7 @@ export class TypeEmitter {
 			return null;
 
 		var typeName = type.name;
-		if (type.genericParameters) {
+		if (type.isGeneric) {
 			var lastArrowIndex = typeName.lastIndexOf("<");
 			typeName = typeName.substr(0, lastArrowIndex);
 		}
@@ -205,13 +201,16 @@ export class TypeEmitter {
 	}
 
 	private generateGenericParametersString(genericParameters: CSharpType[], options: TypeEmitOptions) {
-		var mapping = "<";
+		var mapping = "";
+		
+		mapping += "<";
 		for(var genericParameter of genericParameters) {
 			mapping += this.convertTypeToTypeScript(genericParameter, options);
 			if(genericParameter !== genericParameters[genericParameters.length-1])
 				mapping += ", ";
 		}
 		mapping += ">";
+
 		return mapping;
 	}
 
@@ -225,7 +224,7 @@ export class TypeEmitter {
 			var mappingGenericParameter = mappingKeyType.genericParameters[i];
 			var mappingRealParameter = concreteType.genericParameters[i];
 
-			if (mappingGenericParameter.genericParameters) {
+			if (mappingGenericParameter.isGeneric) {
 				mapping = this.substituteMultipleGenericReferencesIntoMapping(
 					mappingGenericParameter,
 					mappingRealParameter,