#104 - "remove 'parent' to reduce complexity"

readme.md

@@ -113,4 +113,4 @@ abstract class MyClass {
 
 ### Real Life Example
 
-* [Server Bridge](https://github.com/dsherret/server-bridge) - Automatically generates client side code to communicate with the server from the server side code (Out of date)
+* [Server Bridge](https://github.com/dsherret/server-bridge) - Automatically generates client side code to communicate with the server from the server side code

src/WriteFlags.ts

@@ -4,5 +4,6 @@
     HideFunctionBodies = 1 << 1,
     HidePrivateMembers = 1 << 2,
     HideProtectedMembers = 1 << 3,
+    IsInAmbientContext = 1 << 4,
     Default = None
 }

src/binders/base/base.ts

@@ -10,7 +10,6 @@ export * from "./base/ModuledBinder";
 export * from "./base/NamedBinder";
 export * from "./base/ObjectPropertyBinder";
 export * from "./base/ParameteredBinder";
-export * from "./base/ParentedBinder";
 export * from "./base/ReturnTypedBinder";
 export * from "./base/TypeExpressionedBinder";
 export * from "./base/TypeParameteredBinder";

src/binders/base/base/BaseFunctionBinder.ts

@@ -4,7 +4,7 @@ import {ParameteredBinder} from "./ParameteredBinder";
 import {TypeParameteredBinder} from "./TypeParameteredBinder";
 import {ReturnTypedBinder} from "./ReturnTypedBinder";
 
-export abstract class BaseFunctionBinder<ParameterType extends BaseParameterDefinition<any>> {
+export abstract class BaseFunctionBinder<ParameterType extends BaseParameterDefinition> {
     constructor(
         private namedBinder: NamedBinder,
         private typeParameterBinder: TypeParameteredBinder,
@@ -13,7 +13,7 @@ export abstract class BaseFunctionBinder<ParameterType extends BaseParameterDefi
     ) {
     }
 
-    bind(def: BaseFunctionDefinition<any, ParameterType>) {
+    bind(def: BaseFunctionDefinition<ParameterType>) {
         this.namedBinder.bind(def);
         this.typeParameterBinder.bind(def);
         this.parameterBinder.bind(def);

src/binders/base/base/BaseParameterBinder.ts

@@ -14,7 +14,7 @@ export abstract class BaseParameterBinder {
     ) {
     }
 
-    bind(def: BaseParameterDefinition<any>) {
+    bind(def: BaseParameterDefinition) {
         this.namedBinder.bind(def);
         this.typeExpressionedBinder.bind(def);
         this.defaultExpressionedBinder.bind(def);

src/binders/base/base/BasePropertyBinder.ts

@@ -11,7 +11,7 @@ export abstract class BasePropertyBinder {
     ) {
     }
 
-    bind(def: BasePropertyDefinition<any>) {
+    bind(def: BasePropertyDefinition) {
         this.namedBinder.bind(def);
         this.typeExpressionedBinder.bind(def);
         def.isOptional = this.getIsOptional();

src/binders/base/base/DecoratableBinder.ts

@@ -1,10 +1,9 @@
-import {DecoratableDefinition, DecoratorDefinition, DecoratedDefinitions} from "./../../../definitions";
+import {DecoratableDefinition, DecoratorDefinition} from "./../../../definitions";
 
 export abstract class DecoratableBinder {
     abstract getDecorators(): DecoratorDefinition[];
 
     bind(def: DecoratableDefinition) {
         def.decorators.push(...this.getDecorators());
-        def.decorators.forEach(d => d.parent = def as DecoratedDefinitions);
     }
 }

src/binders/base/base/ModuledBinder.ts

@@ -32,7 +32,5 @@ export abstract class ModuledBinder {
         else if (handleCustomDefinition instanceof Function) {
             handleCustomDefinition(member);
         }
-
-        member.parent = def;
     }
 }

src/binders/base/base/ObjectPropertyBinder.ts

@@ -10,7 +10,7 @@ export abstract class ObjectPropertyBinder implements IBaseBinder {
     ) {
     }
 
-    bind(def: ObjectPropertyDefinition<any>) {
+    bind(def: ObjectPropertyDefinition) {
         this.basePropertyBinder.bind(def);
         this.defaultExpressionedBinder.bind(def);
     }

src/binders/base/base/ParameteredBinder.ts

@@ -1,10 +1,9 @@
 import {ParameteredDefinition, BaseParameterDefinition} from "./../../../definitions";
 
-export abstract class ParameteredBinder<ParameterType extends BaseParameterDefinition<any>> {
+export abstract class ParameteredBinder<ParameterType extends BaseParameterDefinition> {
     abstract getParameters(): ParameterType[];
 
     bind(def: ParameteredDefinition<ParameterType>) {
         def.parameters.push(...this.getParameters());
-        def.parameters.forEach(p => p.parent = def);
     }
 }

src/binders/base/base/TypeParameteredBinder.ts

@@ -1,10 +1,9 @@
-import {TypeParameterDefinition, TypeParameteredDefinition, TypeParameteredDefinitions} from "./../../../definitions";
+import {TypeParameterDefinition, TypeParameteredDefinition} from "./../../../definitions";
 
 export abstract class TypeParameteredBinder {
     abstract getTypeParameters(): TypeParameterDefinition[];
 
     bind(def: TypeParameteredDefinition) {
         def.typeParameters.push(...this.getTypeParameters());
-        def.typeParameters.forEach(p => p.parent = def as TypeParameteredDefinitions);
     }
 }

src/binders/base/class/ClassBinder.ts

@@ -54,17 +54,13 @@ export abstract class ClassBinder implements IBaseBinder {
             Logger.warn(`Unknown member member for class.`);
             return;
         }
-
-        member.parent = def;
     }
 
     private fillPropertiesFromConstructorDef(def: ClassDefinition) {
         if (def.constructorDef != null) {
             def.constructorDef.parameters.forEach(param => {
                 if (param.scope !== ClassConstructorParameterScope.None) {
-                    const property = param.toProperty();
-                    property.parent = def;
-                    def.properties.push(property);
+                    def.properties.push(param.toProperty());
                 }
             });
         }

src/binders/base/class/base/BaseClassMethodBinder.ts

@@ -2,7 +2,7 @@
 import {DecoratableBinder, BaseFunctionBinder} from "./../../base";
 import {ScopedBinder} from "./ScopedBinder";
 
-export abstract class BaseClassMethodBinder<ParameterType extends BaseClassMethodParameterDefinition<any>> {
+export abstract class BaseClassMethodBinder<ParameterType extends BaseClassMethodParameterDefinition> {
     constructor(
         private baseFunctionBinder: BaseFunctionBinder<ParameterType>,
         private decoratableBinder: DecoratableBinder,

src/binders/base/class/base/BaseClassMethodParameterBinder.ts

@@ -10,7 +10,7 @@ export abstract class BaseClassMethodParameterBinder {
     ) {
     }
 
-    bind(def: BaseClassMethodParameterDefinition<any>) {
+    bind(def: BaseClassMethodParameterDefinition) {
         this.baseParameterBinder.bind(def);
         this.decoratableBinder.bind(def);
         this.scopedBinder.bind(def);

src/binders/base/enum/EnumBinder.ts

@@ -1,10 +1,8 @@
 import {EnumDefinition, EnumMemberDefinition} from "./../../../definitions";
-import {NamedBinder, ExportableBinder, AmbientableBinder, ParentedBinder} from "./../base";
+import {NamedBinder, ExportableBinder, AmbientableBinder} from "./../base";
 import {IBaseBinder} from "./../IBaseBinder";
 
 export abstract class EnumBinder implements IBaseBinder {
-    private parentedBinder = new ParentedBinder();
-
     constructor(
         private namedBinder: NamedBinder,
         private exportableBinder: ExportableBinder,
@@ -19,8 +17,5 @@ export abstract class EnumBinder implements IBaseBinder {
         this.exportableBinder.bind(def);
         this.ambientableBinder.bind(def);
         def.members.push(...this.getMembers());
-        def.members.forEach(m => {
-            this.parentedBinder.bindParentToChild(def, m);
-        });
     }
 }

src/binders/base/interface/InterfaceBinder.ts

@@ -40,7 +40,5 @@ export abstract class InterfaceBinder implements IBaseBinder {
             Logger.warn(`Not implemented interface member.`);
             return;
         }
-
-        member.parent = def;
     }
 }

src/binders/structure/base/StructureBaseFunctionBinder.ts

@@ -7,7 +7,7 @@ import {StructureTypeParameteredBinder} from "./StructureTypeParameteredBinder";
 import {StructureParameteredBinder, StructureParameterBinderConstructor} from "./StructureParameteredBinder";
 import {StructureReturnTypedBinder} from "./StructureReturnTypedBinder";
 
-export class StructureBaseFunctionBinder<ParameterType extends BaseParameterDefinition<any>, StructureParameterType extends BaseParameterStructure>
+export class StructureBaseFunctionBinder<ParameterType extends BaseParameterDefinition, StructureParameterType extends BaseParameterStructure>
         extends BaseFunctionBinder<ParameterType> {
     constructor(
         factory: StructureFactory,

src/binders/structure/base/StructureParameteredBinder.ts

@@ -2,11 +2,11 @@
 import {BaseParameterDefinitionConstructor, BaseParameterDefinition} from "./../../../definitions";
 import {ParameteredBinder} from "./../../base";
 
-export interface StructureParameterBinderConstructor<ParameterType extends BaseParameterDefinition<any>> {
+export interface StructureParameterBinderConstructor<ParameterType extends BaseParameterDefinition> {
     new(structure: BaseParameterStructure): { bind(def: ParameterType): void; };
 }
 
-export class StructureParameteredBinder<ParameterType extends BaseParameterDefinition<any>, StructureParameterType extends BaseParameterStructure>
+export class StructureParameteredBinder<ParameterType extends BaseParameterDefinition, StructureParameterType extends BaseParameterStructure>
         extends ParameteredBinder<ParameterType> {
     constructor(
         private structure: ParameteredStructure<StructureParameterType>,

src/binders/structure/class/base/StructureBaseClassMethodBinder.ts

@@ -5,7 +5,7 @@ import {BaseClassMethodBinder} from "./../../../base";
 import {StructureDecoratableBinder, StructureBaseFunctionBinder, StructureParameterBinderConstructor} from "./../../base";
 import {StructureScopedBinder} from "./StructureScopedBinder";
 
-export class StructureBaseClassMethodBinder<ParameterType extends BaseClassMethodParameterDefinition<any>, StructureParameterType extends BaseClassMethodParameterStructure>
+export class StructureBaseClassMethodBinder<ParameterType extends BaseClassMethodParameterDefinition, StructureParameterType extends BaseClassMethodParameterStructure>
         extends BaseClassMethodBinder<ParameterType> {
     constructor(
         factory: StructureFactory,

src/binders/ts/base/TsBaseFunctionBinder.ts

@@ -7,7 +7,7 @@ import {TsTypeParameteredBinderByNode} from "./TsTypeParameteredBinderByNode";
 import {TsParameteredBinderByNode, TsParameterBinderByNodeConstructor} from "./TsParameteredBinderByNode";
 import {TsReturnTypedBinderByNode} from "./TsReturnTypedBinderByNode";
 
-export class TsBaseFunctionBinder<ParameterType extends BaseParameterDefinition<any>> extends BaseFunctionBinder<ParameterType> {
+export class TsBaseFunctionBinder<ParameterType extends BaseParameterDefinition> extends BaseFunctionBinder<ParameterType> {
     constructor(
         tsFactory: TsFactory,
         node: TsNode,

src/binders/ts/base/TsParameteredBinderByNode.ts

@@ -3,11 +3,11 @@ import {BaseParameterDefinitionConstructor, BaseParameterDefinition} from "./../
 import {TsFactory} from "./../../../factories";
 import {ParameteredBinder} from "./../../base";
 
-export interface TsParameterBinderByNodeConstructor<ParameterType extends BaseParameterDefinition<any>> {
+export interface TsParameterBinderByNodeConstructor<ParameterType extends BaseParameterDefinition> {
     new(tsFactory: TsFactory, node: TsNode): { bind(def: ParameterType): void; };
 }
 
-export class TsParameteredBinderByNode<ParameterType extends BaseParameterDefinition<any>> extends ParameteredBinder<ParameterType> {
+export class TsParameteredBinderByNode<ParameterType extends BaseParameterDefinition> extends ParameteredBinder<ParameterType> {
     constructor(
         private tsFactory: TsFactory,
         private node: TsNode,

src/binders/ts/base/TsParameteredBinderBySignature.ts

@@ -4,7 +4,7 @@ import {TsFactory} from "./../../../factories";
 import {ParameteredBinder} from "./../../base";
 import {TsParameterBinderByNodeConstructor} from "./TsParameteredBinderByNode";
 
-export class TsParameteredBinderBySignature<ParameterType extends BaseParameterDefinition<any>> extends ParameteredBinder<ParameterType> {
+export class TsParameteredBinderBySignature<ParameterType extends BaseParameterDefinition> extends ParameteredBinder<ParameterType> {
     constructor(
         private tsFactory: TsFactory,
         private signature: TsSignature,

src/binders/ts/class/base/TsBaseClassMethodBinder.ts

@@ -5,7 +5,7 @@ import {BaseClassMethodBinder} from "./../../../base";
 import {TsDecoratableBinder, TsBaseFunctionBinder, TsParameterBinderByNodeConstructor} from "./../../base";
 import {TsScopedBinder} from "./TsScopedBinder";
 
-export class TsBaseClassMethodBinder<ParameterType extends BaseClassMethodParameterDefinition<any>> extends BaseClassMethodBinder<ParameterType> {
+export class TsBaseClassMethodBinder<ParameterType extends BaseClassMethodParameterDefinition> extends BaseClassMethodBinder<ParameterType> {
     constructor(
         tsFactory: TsFactory,
         node: TsNode,

src/definitions/base.ts

@@ -1,7 +1,6 @@
 export * from "./base/BaseDefinition";
 export * from "./base/DefinitionType";
 export * from "./base/NamedDefinition";
-export * from "./base/ParentedDefinition";
 export * from "./base/AbstractableDefinition";
 export * from "./base/AmbientableDefinition";
 export * from "./base/TypeExpressionedDefinition";

src/definitions/base/BaseFunctionDefinition.ts

@@ -3,24 +3,21 @@ import {TypeParameterStructure} from "./../../structures";
 import {applyMixins} from "./../../utils";
 import {TypeParameterDefinition} from "./../general";
 import {NamedDefinition} from "./NamedDefinition";
-import {ParentedDefinition} from "./ParentedDefinition";
 import {TypeParameteredDefinition} from "./TypeParameteredDefinition";
 import {BaseDefinition} from "./BaseDefinition";
 import {DefinitionType} from "./DefinitionType";
 import {ParameteredDefinition} from "./ParameteredDefinition";
 import {ReturnTypedDefinition} from "./ReturnTypedDefinition";
 
-export class BaseFunctionDefinition<ParentType, ParameterType>
+export class BaseFunctionDefinition<ParameterType>
         extends BaseDefinition
-        implements NamedDefinition, ParentedDefinition<ParentType>, TypeParameteredDefinition, ParameteredDefinition<ParameterType>, ReturnTypedDefinition {
+        implements NamedDefinition, TypeParameteredDefinition, ParameteredDefinition<ParameterType>, ReturnTypedDefinition {
     constructor(definitionType: DefinitionType) {
         super(definitionType);
     }
 
     // NamedDefinition
     name: string;
-    // IParentedDefinition
-    parent: ParentType;
     // ParameteredDefinition
     parameters: ParameterType[];
     // ReturnTyped

src/definitions/base/BaseParameterDefinition.ts

@@ -1,7 +1,6 @@
 import {applyMixins} from "./../../utils";
 import {TypeExpressionDefinition, ExpressionDefinition} from "./../expressions";
 import {NamedDefinition} from "./NamedDefinition";
-import {ParentedDefinition} from "./ParentedDefinition";
 import {TypeExpressionedDefinition} from "./TypeExpressionedDefinition";
 import {DefaultExpressionedDefinition} from "./DefaultExpressionedDefinition";
 import {BaseDefinition} from "./BaseDefinition";
@@ -11,8 +10,7 @@ export interface BaseParameterDefinitionConstructor<ParameterType> {
     new(): ParameterType;
 }
 
-export class BaseParameterDefinition<ParentType> extends BaseDefinition
-                                                 implements NamedDefinition, ParentedDefinition<ParentType>, TypeExpressionedDefinition, DefaultExpressionedDefinition {
+export class BaseParameterDefinition extends BaseDefinition implements NamedDefinition, TypeExpressionedDefinition, DefaultExpressionedDefinition {
     isOptional: boolean;
     isRestParameter: boolean;
 
@@ -22,8 +20,6 @@ export class BaseParameterDefinition<ParentType> extends BaseDefinition
 
     // NamedDefinition
     name: string;
-    // IParentedDefinition
-    parent: ParentType;
     // TypeExpressionedDefinition
     typeExpression: TypeExpressionDefinition;
     // DefaultExpressionedDefinition

src/definitions/base/BasePropertyDefinition.ts

@@ -1,12 +1,11 @@
 import {applyMixins} from "./../../utils";
 import {TypeExpressionDefinition} from "./../expressions";
 import {NamedDefinition} from "./NamedDefinition";
-import {ParentedDefinition} from "./ParentedDefinition";
 import {TypeExpressionedDefinition} from "./TypeExpressionedDefinition";
 import {DefinitionType} from "./DefinitionType";
 import {BaseDefinition} from "./BaseDefinition";
 
-export class BasePropertyDefinition<ParentType> extends BaseDefinition implements NamedDefinition, ParentedDefinition<ParentType>, TypeExpressionedDefinition {
+export class BasePropertyDefinition extends BaseDefinition implements NamedDefinition, TypeExpressionedDefinition {
     isOptional: boolean;
 
     constructor(definitionType: DefinitionType) {
@@ -15,8 +14,6 @@ export class BasePropertyDefinition<ParentType> extends BaseDefinition implement
 
     // NamedDefinition
     name: string;
-    // IParentedDefinition
-    parent: ParentType;
     // TypeExpressionedDefinition
     typeExpression: TypeExpressionDefinition;
 }

src/definitions/base/DecoratableDefinition.ts

@@ -7,7 +7,6 @@ export abstract class DecoratableDefinition {
         const factory = new StructureFactory();
         decorators.forEach(decorator => {
             const def = factory.getDecorator(decorator);
-            def.parent = this as any;
             this.decorators.push(def);
         });
         return this;

src/definitions/base/ObjectPropertyDefinition.ts

@@ -4,7 +4,7 @@ import {DefinitionType} from "./DefinitionType";
 import {DefaultExpressionedDefinition} from "./DefaultExpressionedDefinition";
 import {BasePropertyDefinition} from "./BasePropertyDefinition";
 
-export abstract class ObjectPropertyDefinition<ParentType> extends BasePropertyDefinition<ParentType> implements DefaultExpressionedDefinition {
+export abstract class ObjectPropertyDefinition extends BasePropertyDefinition implements DefaultExpressionedDefinition {
     constructor(definitionType: DefinitionType) {
         super(definitionType);
     }

src/definitions/base/TypeParameteredDefinition.ts

@@ -5,11 +5,7 @@ import {TypeParameterDefinition} from "./../general";
 export abstract class TypeParameteredDefinition {
     addTypeParameters(...typeParameters: TypeParameterStructure[]) {
         const factory = new StructureFactory();
-        typeParameters.forEach(typeParameter => {
-            const def = factory.getTypeParameter(typeParameter);
-            def.parent = this as any;
-            this.typeParameters.push(def);
-        });
+        typeParameters.forEach(typeParameter => this.typeParameters.push(factory.getTypeParameter(typeParameter)));
         return this;
     }
 

src/definitions/class/ClassConstructorDefinition.ts

@@ -1,20 +1,17 @@
 import CodeBlockWriter from "code-block-writer";
-import {ParentedDefinition, BaseDefinition, DefinitionType, ParameteredDefinition} from "./../base";
+import {BaseDefinition, DefinitionType, ParameteredDefinition} from "./../base";
 import {applyMixins} from "./../../utils";
 import {ClassConstructorParameterDefinition} from "./ClassConstructorParameterDefinition";
-import {ClassDefinition} from "./ClassDefinition";
 
 export class ClassConstructorDefinition
         extends BaseDefinition
-        implements ParentedDefinition<ClassDefinition>, ParameteredDefinition<ClassConstructorParameterDefinition> {
+        implements ParameteredDefinition<ClassConstructorParameterDefinition> {
     onWriteFunctionBody: (writer: CodeBlockWriter) => void;
 
     constructor() {
         super(DefinitionType.ClassConstructor);
     }
 
-    // IParentedDefinition
-    parent: ClassDefinition;
     // ParameteredDefinition
     parameters: ClassConstructorParameterDefinition[];
 }