Merge pull request #22 from huan086/inheritance-hierarchy

Emit class and interface that inherits, even when the body is empty.

Author: ffMathy

spec/FileEmitterSpec.ts

@@ -63,7 +63,8 @@ describe("UseCases", function () {
 	runCase("Enum");
 	runCase("Property");
 	runCase("Class");
-	
+	runCase("Interface");
+
 	runCase("AspNetCoreControllerToAngularClient", () => {
 		var controllerClassFilter = (classObject: CSharpClass) => {
 			var isTypeController = (type: {name: string}) => type.name.endsWith("Controller");

spec/cases/Class.case.cs

@@ -28,4 +28,13 @@ public class SubClass
 class OtherClass
 {
 	public string MyProperty { get; set; }
-}
+}
+
+class BaseGenericClass<T>
+{
+    public T MyProperty { get; set; }
+}
+
+class ConcreteTypeClass : BaseGenericClass<long>
+{
+}

spec/cases/Class.expected.d.ts

@@ -20,4 +20,11 @@ declare namespace MainClass {
 
 declare interface OtherClass {
 	myProperty: string;
+}
+
+declare interface BaseGenericClass<T> {
+	myProperty: T;
+}
+
+declare interface ConcreteTypeClass extends BaseGenericClass<number> {
 }

spec/cases/Interface.case.cs

@@ -0,0 +1,33 @@
+interface IBefore
+{
+	string MyProperty { get; set; }
+
+	void MyMethod(string foo, params string[] bar);
+
+	void MyNullParameterMethod(string foo = null);
+
+	Task<IEnumerable<string>> TaskArrayMethod();
+}
+
+interface IMain<Foo> where Foo : new()
+{
+	string MyProperty { get; set; }
+
+	SomeStuff<OtherStuff, RegularStuff> BlahProperty { get; set; }
+
+	List<OtherStuff> OtherBlahProperty { get; set; }
+}
+
+interface IOther
+{
+	string MyProperty { get; set; }
+}
+
+interface IGeneric<T>
+{
+    T MyProperty { get; set; }
+}
+
+interface IConcreteType : IGeneric<long>
+{
+}

spec/cases/Interface.expected.d.ts

@@ -0,0 +1,23 @@
+declare interface IBefore {
+	myProperty: string;
+	myMethod(foo: string, ...bar: Array<string>): void;
+	myNullParameterMethod(foo?: string): void;
+	taskArrayMethod(): Promise<Array<string>>;
+}
+
+declare interface IMain<Foo> {
+	myProperty: string;
+	blahProperty: SomeStuff<OtherStuff, RegularStuff>;
+	otherBlahProperty: Array<OtherStuff>;
+}
+
+declare interface IOther {
+	myProperty: string;
+}
+
+declare interface IGeneric<T> {
+	myProperty: T;
+}
+
+declare interface IConcreteType extends IGeneric<number> {
+}

src/ClassEmitter.ts

@@ -99,7 +99,8 @@ export class ClassEmitter {
 		var hasDirectChildren = 
 			classObject.properties.length > 0 || 
 			classObject.methods.length > 0 || 
-			classObject.fields.length > 0;
+			classObject.fields.length > 0 ||
+			classObject.inheritsFrom.length > 0;
 
 		if (!hasDirectChildren && !hasNestedChildren) {
 			this.logger.log("Skipping emitting body of class " + classObject.name + " because it contains no children");

src/InterfaceEmitter.ts

@@ -77,7 +77,7 @@ export class InterfaceEmitter {
 		if (!options.filter(interfaceObject))
 			return [];
 
-		if (interfaceObject.properties.length === 0 && interfaceObject.methods.length === 0) {
+		if (interfaceObject.properties.length === 0 && interfaceObject.methods.length === 0 && interfaceObject.implements.length === 0) {
 			this.logger.log("Skipping emitting body of interface " + interfaceObject.name + " because it contains no properties or methods");
 			return [];
 		}

src/TypeEmitter.ts

@@ -70,7 +70,7 @@ export class TypeEmitter {
 		var typeName = this.getNonGenericMatchingTypeMappingAsString(type, options);
 		return ts.createExpressionWithTypeArguments(
 			this.createTypeScriptTypeReferenceNodes(
-				type.genericParameters,
+				type.genericParameters.map(p => this.getMatchingTypeMappingAsType(p, options)),
 				options),
 			ts.createIdentifier(typeName));
 	}