/// <summary> /// Exports all type members sequentially /// </summary> /// <param name="element">Type itself</param> /// <param name="resolver">Type resolver</param> /// <param name="typeMember">Placeholder for members</param> /// <param name="swtch">Pass here type attribute inherited from IAutoexportSwitchAttribute</param> protected virtual void ExportMembers(Type element, TypeResolver resolver, ITypeMember typeMember, IAutoexportSwitchAttribute swtch) { ExportConstructors(typeMember, element, resolver, swtch); ExportFields(typeMember, element, resolver, swtch); ExportProperties(typeMember, element, resolver, swtch); ExportMethods(typeMember, element, resolver, swtch); HandleBaseClassExportingAsInterface(typeMember, element, resolver, swtch); }
/// <summary> /// Exports entire class to specified writer /// </summary> /// <param name="declType"> /// Declaration type. Used in "export $gt;class< ... " line. This parameter allows switch it to /// "interface" /// </param> /// <param name="type">Exporting class type</param> /// <param name="resolver">Type resolver</param> /// <param name="sw">Output writer</param> /// <param name="swtch">Pass here type attribute inherited from IAutoexportSwitchAttribute</param> protected virtual void Export(string declType, Type type, TypeResolver resolver, WriterWrapper sw, IAutoexportSwitchAttribute swtch) { var name = type.GetName(); Settings.Documentation.WriteDocumentation(type, sw); sw.Indent(); sw.Write(Settings.GetDeclarationFormat(type), declType); sw.Write(name); var ifaces = type.GetInterfaces(); var bs = type.BaseType; var baseClassIsExportedAsInterface = false; if (bs != null && bs != typeof(object)) { if (ConfigurationRepository.Instance.ForType <TsDeclarationAttributeBase>(bs) != null) { if (bs.IsExportingAsInterface()) { baseClassIsExportedAsInterface = true; } else { sw.Write(" extends {0} ", resolver.ResolveTypeName(bs)); } } } var ifacesStrings = ifaces.Where(c => ConfigurationRepository.Instance.ForType <TsInterfaceAttribute>(c) != null) .Select(resolver.ResolveTypeName).ToList(); if (baseClassIsExportedAsInterface) { ifacesStrings.Add(resolver.ResolveTypeName(bs)); } if (ifacesStrings.Any()) { var implemets = string.Join(", ", ifacesStrings); if (type.IsExportingAsInterface()) { sw.Write(" extends {0}", implemets); } else { sw.Write(" implements {0}", implemets); } } sw.Write(" {{"); sw.WriteLine(); ExportMembers(type, resolver, sw, swtch); sw.WriteLine("}"); }
/// <summary> /// Exports type constructors /// </summary> /// <param name="element">Type itself</param> /// <param name="resolver">Type resolver</param> /// <param name="sw">Output writer</param> /// <param name="swtch">Pass here type attribute inherited from IAutoexportSwitchAttribute</param> protected virtual void ExportConstructors(Type element, TypeResolver resolver, WriterWrapper sw, IAutoexportSwitchAttribute swtch) { if (swtch.AutoExportConstructors) { if (!element.IsExportingAsInterface()) // constructors are not allowed on interfaces { var constructors = element.GetConstructors(TypeExtensions.MembersFlags) .Where(c => TypeExtensions.TypeScriptMemberSearchPredicate(c)); GenerateMembers(element, resolver, sw, constructors); } } }
/// <summary> /// Here you can customize what to export when base class is class but exporting as interface /// </summary> /// <param name="element">Type itself</param> /// <param name="resolver">Type resolver</param> /// <param name="sw">Output writer</param> /// <param name="swtch">Pass here type attribute inherited from IAutoexportSwitchAttribute</param> protected virtual void HandleBaseClassExportingAsInterface(Type element, TypeResolver resolver, WriterWrapper sw, IAutoexportSwitchAttribute swtch) { if (element.BaseType != null) { if ( element.BaseType.IsExportingAsInterface() && !element.IsExportingAsInterface()) { // well.. bad but often case. // Here we should export members also for base class // we do not export methods - just properties and fields // but still. It is better thatn nothing Settings.Documentation.WriteComment(sw, string.Format("Automatically implemented from {0}", resolver.ResolveTypeName(element.BaseType))); var basExSwtch = ConfigurationRepository.Instance.ForType <TsInterfaceAttribute>(element.BaseType); Settings.SpecialCase = true; ExportFields(element.BaseType, resolver, sw, basExSwtch); ExportMethods(element.BaseType, resolver, sw, basExSwtch); Settings.SpecialCase = false; } } }
/// <summary> /// Exports type constructors /// </summary> /// <param name="typeMember">Output writer</param> /// <param name="element">Type itself</param> /// <param name="resolver">Type resolver</param> /// <param name="swtch">Pass here type attribute inherited from IAutoexportSwitchAttribute</param> protected virtual void ExportConstructors(ITypeMember typeMember, Type element, TypeResolver resolver, IAutoexportSwitchAttribute swtch) { var bp = Context.Project.Blueprint(element); if (swtch.AutoExportConstructors) { if (!bp.IsExportingAsInterface()) // constructors are not allowed on interfaces { var constructors = element._GetConstructors(TypeExtensions.MembersFlags) .Where(c => (c.GetCustomAttribute <CompilerGeneratedAttribute>() == null) && !bp.IsIgnored(c)); if (!constructors.Any()) { constructors = element._GetConstructors(TypeExtensions.MembersFlags) .Where(c => !bp.IsIgnored(c)); } GenerateMembers(element, resolver, typeMember, constructors.Take(1)); } } }
/// <summary> /// Exports type methods /// </summary> /// <param name="typeMember">Output writer</param> /// <param name="element">Type itself</param> /// <param name="resolver">Type resolver</param> /// <param name="swtch">Pass here type attribute inherited from IAutoexportSwitchAttribute</param> protected virtual void ExportMethods(ITypeMember typeMember, Type element, TypeResolver resolver, IAutoexportSwitchAttribute swtch) { GenerateMembers(element, resolver, typeMember, Context.Project.Blueprint(element).GetExportedMethods()); }
/// <summary> /// Exports entire class to specified writer /// </summary> /// <param name="result">Exporting result</param> /// <param name="type">Exporting class type</param> /// <param name="resolver">Type resolver</param> /// <param name="swtch">Pass here type attribute inherited from IAutoexportSwitchAttribute</param> protected virtual void Export(ITypeMember result, Type type, TypeResolver resolver, IAutoexportSwitchAttribute swtch) { var bp = Context.Project.Blueprint(type); result.Name = bp.GetName(); result.Order = bp.GetOrder(); var doc = Context.Documentation.GetDocumentationMember(type); if (doc != null) { RtJsdocNode docNode = new RtJsdocNode(); if (doc.HasSummary()) { docNode.Description = doc.Summary.Text; } result.Documentation = docNode; } var materializedGenericParameters = type._GetGenericArguments() .Where(c => c.GetCustomAttribute <TsGenericAttribute>() != null) .ToDictionary(c => c.Name, resolver.ResolveTypeName); if (materializedGenericParameters.Count == 0) { materializedGenericParameters = null; } if (!bp.IsFlatten()) { var bs = type._BaseType(); var baseClassIsExportedAsInterface = false; if (bs != null && bs != typeof(object)) { bool baseAsInterface = false; RtTypeName inferredBaseType = null; if (bs._IsGenericType()) { var genericBase = bs.GetGenericTypeDefinition(); var genericBaseBp = Context.Project.Blueprint(genericBase); if (genericBaseBp.TypeAttribute != null || genericBaseBp.ThirdParty != null) { inferredBaseType = resolver.ResolveTypeName(bs, MergeMaterializedGenerics(bs, resolver, materializedGenericParameters)); baseAsInterface = Context.Project.Blueprint(genericBase).IsExportingAsInterface(); } } if (inferredBaseType == null || !bs._IsGenericType()) { var bsBp = Context.Project.Blueprint(bs); if (bsBp.TypeAttribute != null || bsBp.ThirdParty != null) { baseAsInterface = Context.Project.Blueprint(bs).IsExportingAsInterface(); inferredBaseType = resolver.ResolveTypeName(bs, MergeMaterializedGenerics(bs, resolver, materializedGenericParameters)); } } if (inferredBaseType != null) { if (baseAsInterface) { baseClassIsExportedAsInterface = true; } else { ((RtClass)result).Extendee = inferredBaseType; } } } var implementees = ExtractImplementees(type, resolver, materializedGenericParameters).ToList(); if (baseClassIsExportedAsInterface) { implementees.Add(resolver.ResolveTypeName(bs, materializedGenericParameters)); } result.Implementees.AddRange(implementees.OfType <RtSimpleTypeName>()); } ExportMembers(type, resolver, result, swtch); }
/// <summary> /// Here you can customize what to export when base class is class but exporting as interface /// </summary> /// <param name="sw">Output writer</param> /// <param name="element">Type itself</param> /// <param name="resolver">Type resolver</param> /// <param name="swtch">Pass here type attribute inherited from IAutoexportSwitchAttribute</param> protected virtual void HandleBaseClassExportingAsInterface(ITypeMember sw, Type element, TypeResolver resolver, IAutoexportSwitchAttribute swtch) { if (element._BaseType() != null) { var baseBp = Context.Project.Blueprint(element._BaseType()); var bp = Context.Project.Blueprint(element); if (baseBp.IsExportingAsInterface() && !bp.IsExportingAsInterface()) { // well.. bad but often case. // Here we should export members also for base class // we do not export methods - just properties and fields // but still. It is better thatn nothing if (sw.Documentation == null) { sw.Documentation = new RtJsdocNode(); } sw.Documentation.TagToDescription.Add(new Tuple <DocTag, string>(DocTag.Todo, string.Format("Automatically implemented from {0}", resolver.ResolveTypeName(element._BaseType())))); var baseBlueprint = Context.Project.Blueprint(element._BaseType()); var basExSwtch = baseBlueprint.Attr <TsInterfaceAttribute>(); Context.SpecialCase = true; ExportFields(sw, element._BaseType(), resolver, basExSwtch); ExportProperties(sw, element._BaseType(), resolver, basExSwtch); ExportMethods(sw, element._BaseType(), resolver, basExSwtch); Context.SpecialCase = false; Context.Warnings.Add(ErrorMessages.RTW0005_BaseClassExportingAsInterface.Warn(element._BaseType().FullName, element.FullName)); } } }
/// <summary> /// Exports entire class to specified writer /// </summary> /// <param name="result">Exporting result</param> /// <param name="type">Exporting class type</param> /// <param name="resolver">Type resolver</param> /// <param name="swtch">Pass here type attribute inherited from IAutoexportSwitchAttribute</param> protected virtual void Export(ITypeMember result, Type type, TypeResolver resolver, IAutoexportSwitchAttribute swtch) { Context.Location.SetCurrentType(type); result.Name = type.GetName(); result.Order = type.GetOrder(); var doc = Context.Documentation.GetDocumentationMember(type); if (doc != null) { RtJsdocNode docNode = new RtJsdocNode(); if (doc.HasSummary()) { docNode.Description = doc.Summary.Text; } result.Documentation = docNode; } var materializedGenericParameters = type.GetGenericArguments() .Where(c => c.GetCustomAttribute <TsGenericAttribute>() != null) .ToDictionary(c => c.Name, resolver.ResolveTypeName); if (materializedGenericParameters.Count == 0) { materializedGenericParameters = null; } var bs = type.BaseType; var baseClassIsExportedAsInterface = false; if (bs != null && bs != typeof(object)) { TsDeclarationAttributeBase attr = null; bool baseAsInterface = false; if (bs.IsGenericType) { var genericBase = bs.GetGenericTypeDefinition(); attr = ConfigurationRepository.Instance.ForType <TsDeclarationAttributeBase>(genericBase); baseAsInterface = genericBase.IsExportingAsInterface(); } else { attr = ConfigurationRepository.Instance.ForType <TsDeclarationAttributeBase>(bs); baseAsInterface = bs.IsExportingAsInterface(); } if (attr != null) { if (baseAsInterface) { baseClassIsExportedAsInterface = true; } else { ((RtClass)result).Extendee = resolver.ResolveTypeName(bs, MergeMaterializedGenerics(bs, resolver, materializedGenericParameters)); } } } var implementees = ExtractImplementees(type, resolver, materializedGenericParameters).ToList(); if (baseClassIsExportedAsInterface) { implementees.Add(resolver.ResolveTypeName(bs, materializedGenericParameters)); } result.Implementees.AddRange(implementees.OfType <RtSimpleTypeName>()); ExportMembers(type, resolver, result, swtch); Context.Location.ResetCurrentType(); }
/// <summary> /// Exports type methods /// </summary> /// <param name="typeMember">Output writer</param> /// <param name="element">Type itself</param> /// <param name="resolver">Type resolver</param> /// <param name="swtch">Pass here type attribute inherited from IAutoexportSwitchAttribute</param> protected virtual void ExportMethods(ITypeMember typeMember, Type element, TypeResolver resolver, IAutoexportSwitchAttribute swtch) { GenerateMembers(element, resolver, typeMember, element.GetExportedMethods()); }
/// <summary> /// Exports type methods /// </summary> /// <param name="element">Type itself</param> /// <param name="resolver">Type resolver</param> /// <param name="sw">Output writer</param> /// <param name="swtch">Pass here type attribute inherited from IAutoexportSwitchAttribute</param> protected virtual void ExportMethods(Type element, TypeResolver resolver, WriterWrapper sw, IAutoexportSwitchAttribute swtch) { GenerateMembers(element, resolver, sw, element.GetExportedMethods()); }
/// <summary> /// Exports entire class to specified writer /// </summary> /// <param name="result">Exporting result</param> /// <param name="type">Exporting class type</param> /// <param name="resolver">Type resolver</param> /// <param name="swtch">Pass here type attribute inherited from IAutoexportSwitchAttribute</param> protected virtual void Export(ITypeMember result, Type type, TypeResolver resolver, IAutoexportSwitchAttribute swtch) { result.Name = type.GetName(); var doc = Context.Documentation.GetDocumentationMember(type); if (doc != null) { RtJsdocNode docNode = new RtJsdocNode(); if (doc.HasSummary()) { docNode.Description = doc.Summary.Text; } result.Documentation = docNode; } var ifaces = type.GetInterfaces(); var bs = type.BaseType; var baseClassIsExportedAsInterface = false; if (bs != null && bs != typeof(object)) { if (ConfigurationRepository.Instance.ForType <TsDeclarationAttributeBase>(bs) != null) { if (bs.IsExportingAsInterface()) { baseClassIsExportedAsInterface = true; } else { ((RtClass)result).Extendee = resolver.ResolveTypeName(bs); } } } var implementees = ifaces.Where(c => ConfigurationRepository.Instance.ForType <TsInterfaceAttribute>(c) != null) .Select(resolver.ResolveTypeName).ToList(); if (baseClassIsExportedAsInterface) { implementees.Add(resolver.ResolveTypeName(bs)); } result.Implementees.AddRange(implementees.OfType <RtSimpleTypeName>()); ExportMembers(type, resolver, result, swtch); }