public override IEnumerable <MemberDeclarationSyntax> Generate() { string className = ((QualifiedNameSyntax)TypeInfo.Name).Right.Identifier.ValueText; ClassDeclarationSyntax declaration = ClassDeclaration(className) .AddElementAnnotation(Element, Context.ElementRegistry) .AddGeneratorAnnotation(this) .AddModifiers(Token(SyntaxKind.PublicKeyword)) .AddBaseListTypes(SimpleBaseType(RequestTypeGenerator.TypeInfo.Name)) .AddMembers(ConstructorDeclaration(className) .AddModifiers(Token(SyntaxKind.PublicKeyword)) .WithBody(Block())); var schema = Element.GetSchemaOrDefault(); declaration = declaration.AddMembers(CreateBodyPropertyDeclaration(schema)); if (schema.Element.Reference == null) { ITypeGenerator schemaGenerator = Context.TypeGeneratorRegistry.Get(schema); MemberDeclarationSyntax[] childMembers = schemaGenerator.Generate().ToArray(); if (childMembers.Length > 0) { declaration = declaration.AddMembers(childMembers); } } yield return(declaration.AddMembers( BuildContentMethodGenerator.Generate(RequestTypeGenerator.Element, Element))); }
public IEnumerable <BaseMethodDeclarationSyntax> Generate(ILocatedOpenApiElement <OpenApiResponse> response, string className) { if (!response.IsRoot() && response.Element.Reference != null) { // Do not generator for responses within operations that are references to components, these will inherit // their get body method from the component base class yield break; } if (response.Element.Content == null) { yield break; } ILocatedOpenApiElement <OpenApiMediaType>?mediaType = MediaTypeSelector.Select(response); ILocatedOpenApiElement <OpenApiSchema>? schema = mediaType?.GetSchema(); if (schema == null) { yield break; } ITypeGenerator schemaGenerator = Context.TypeGeneratorRegistry.Get(schema); TypeSyntax returnType = schemaGenerator.TypeInfo.Name; yield return(MethodDeclaration( WellKnownTypes.System.Threading.Tasks.ValueTaskT.Name(returnType), GetBodyMethodName) .AddModifiers(Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.AsyncKeyword)) .WithBody(Block(GenerateStatements(response, returnType)))); }
public MethodDeclarationSyntax?Generate(ILocatedOpenApiElement <OpenApiResponse> response) { if (response.Element.Content == null) { return(null); } ILocatedOpenApiElement <OpenApiMediaType>?mediaType = MediaTypeSelector.Select(response); ILocatedOpenApiElement <OpenApiSchema>? schema = mediaType?.GetSchema(); if (schema == null) { return(null); } ITypeGenerator schemaGenerator = Context.SchemaGeneratorRegistry.Get(schema); TypeSyntax returnType = schemaGenerator.TypeName; return(MethodDeclaration( WellKnownTypes.System.Threading.Tasks.ValueTaskT.Name(returnType), GetBodyMethodName) .AddModifiers(Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.AsyncKeyword)) .WithBody(Block(GenerateStatements(response, returnType)))); }
protected virtual IEnumerable <MemberDeclarationSyntax> GenerateHeaderProperties() { var nameFormatter = Context.NameFormatterSelector.GetFormatter(NameKind.Property); foreach (var header in Element.GetHeaders()) { ILocatedOpenApiElement <OpenApiSchema> schemaElement = header.GetSchemaOrDefault(); ITypeGenerator schemaGenerator = Context.SchemaGeneratorRegistry.Get(schemaElement); yield return(PropertyDeclaration(schemaGenerator.TypeName, nameFormatter.Format(header.Key)) .AddElementAnnotation(header, Context.ElementRegistry) .AddModifiers(Token(SyntaxKind.PublicKeyword)) .AddAccessorListAccessors( AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) .WithSemicolonToken(Token(SyntaxKind.SemicolonToken)), AccessorDeclaration(SyntaxKind.SetAccessorDeclaration) .WithSemicolonToken(Token(SyntaxKind.SemicolonToken)))); if (schemaElement.Element.Reference == null) { foreach (var memberDeclaration in schemaGenerator.Generate()) { yield return(memberDeclaration); } } } }
public TypeScriptType ReferenceFrom(TypeScriptUnit targetUnit, ITypeGenerator typeGenerator, IAttributeProvider?attributeProvider) { var itemType = typeGenerator.ResolveType(elementType).ReferenceFrom(targetUnit, typeGenerator, null); var resultType = TypeScriptGeneratorHelpers.BuildTargetNullableTypeByOptions(itemType, CanItemBeNull(attributeProvider), options); return(new TypeScriptArrayType(resultType)); }
public override void Initialize(ITypeGenerator typeGenerator) { var definition = new TypeScriptInterfaceDefinition(); definition.Members.AddRange(Type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly) .Where(m => !m.Name.Contains("_")) .Select(m => new TypeScriptInterfaceFunctionMember(m.Name.ToLowerCamelCase(), typeGenerator.BuildAndImportType(Unit, m.ReturnType), m.GetParameters() .Select(p => new TypeScriptArgumentDeclaration { Name = p.Name, Optional = false, Type = typeGenerator.BuildAndImportType(Unit, p.ParameterType), }) .ToArray()))); definition.Members.AddRange(Type.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly) .Select(x => new TypeScriptInterfacePropertyMember(x.Name.ToLowerCamelCase(), typeGenerator.BuildAndImportType(Unit, x.PropertyType)))); Declaration = new TypeScriptInterfaceDeclaration { Definition = definition, Name = Type.Name }; base.Initialize(typeGenerator); }
internal SubstituteTypesVisitor( IDictionary <TType1, TType2> map, ITypeGenerator typeGenerator) { this.map = map; this.typeGenerator = typeGenerator; }
public TypeScriptType ReferenceFrom(TypeScriptUnit targetUnit, ITypeGenerator typeGenerator, IAttributeProvider?attributeProvider) { if (builtinTypes.ContainsKey(type)) { return(new TypeScriptBuildInType(builtinTypes[type])); } throw new ArgumentOutOfRangeException(); }
public TypeScriptType ReferenceFrom(TypeScriptUnit targetUnit, ITypeGenerator typeGenerator) { return(targetUnit.AddTypeImport(type, new TypeScriptInterfaceDeclaration { Name = typeName }, new TypeScriptUnit { Path = path })); }
public TypeScriptType ReferenceFrom(TypeScriptUnit targetUnit, ITypeGenerator typeGenerator) { var itemTypeScriptType = typeGenerator.ResolveType(itemType).ReferenceFrom(targetUnit, typeGenerator); return(useGlobalNullable ? (TypeScriptType) new TypeScriptNullableType(itemTypeScriptType) : new TypeScriptOrNullType(itemTypeScriptType)); }
public static ITypeSymbol SubstituteTypes <TType1, TType2>( this ITypeSymbol type, IDictionary <TType1, TType2> mapping, ITypeGenerator typeGenerator) where TType1 : ITypeSymbol where TType2 : ITypeSymbol { return(type?.Accept(new SubstituteTypesVisitor <TType1, TType2>(mapping, typeGenerator))); }
protected virtual TypeScriptTypeDefintion CreateComplexTypeScriptDefinition(ITypeGenerator typeGenerator) { var result = new TypeScriptTypeDefintion(); result.Members.AddRange(Type.GetProperties(BindingFlags.Instance | BindingFlags.Public) .Select(x => typeGenerator.ResolveProperty(Unit, Type, x)) .Where(x => x != null)); return(result); }
public ITypeBuildingContext ResolveType(string initialUnitPath, ITypeGenerator typeGenerator, ITypeInfo type, ITypeScriptUnitFactory unitFactory) { if (InternalApiTypeBuildingContext.Accept(type)) { return(new InternalApiTypeBuildingContext(unitFactory.GetOrCreateTypeUnit(initialUnitPath), type)); } return(null); }
public override void BuildDefinition(ITypeGenerator typeGenerator) { var types = Type.Assembly .GetTypes() .Where(x => !x.Equals(Type) && Type.IsAssignableFrom(x) && (useAbstractChildren || !x.IsAbstract)) .Select(x => typeGenerator.BuildAndImportType(Unit, x).NotNull()) .ToArray(); Declaration.Definition = new TypeScriptUnionType(types); }
public override void BuildDefinition(ITypeGenerator typeGenerator) { var types = typeGenerator.TypesProvider .GetAssemblyTypes(Type) .Where(x => !x.Equals(Type) && Type.IsAssignableFrom(x) && (useAbstractChildren || !x.IsAbstract)) .Select(x => typeGenerator.ResolveType(x).ReferenceFrom(Unit, typeGenerator, null)) .ToArray(); Declaration.Definition = new TypeScriptUnionType(types); }
public override void BuildDefinition(ITypeGenerator typeGenerator) { var types = Type.Assembly .GetTypes() .Where(x => x != Type && Type.IsAssignableFrom(x) && (useAbstractChildren || !x.IsAbstract)) .Select(x => typeGenerator.ResolveType(x).ReferenceFrom(Unit, typeGenerator)) .ToArray(); Declaration.Definition = new TypeScriptUnionType(types); }
private static TypeScriptType GetArgumentType(ITypeInfo argument, ITypeGenerator typeGenerator, TypeScriptUnit targetUnit) { var targetType = typeGenerator.BuildAndImportType(targetUnit, argument); if (typeGenerator.Options.NullabilityMode == NullabilityMode.NullableReference) { return(targetType); } return(targetType.NotNull()); }
public override void Initialize(ITypeGenerator typeGenerator) { Declaration = new TypeScriptTypeDeclaration { Name = Type.Name, Definition = null }; Unit.Body.Add(new TypeScriptExportStatement { Declaration = Declaration }); }
public override void Initialize(ITypeGenerator typeGenerator) { var definition = new TypeScriptInterfaceDefinition(); definition.Members.AddRange(Type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly) .Select(x => new TypeScriptInterfaceFunctionMember(x.Name, typeGenerator.BuildAndImportType(Unit, x, x.ReturnType)))); Declaration = new TypeScriptInterfaceDeclaration { Definition = definition, Name = Type.Name }; base.Initialize(typeGenerator); }
public TypeScriptType ReferenceFrom(TypeScriptUnit targetUnit, ITypeGenerator typeGenerator) { var typeReference = typeGenerator.ResolveType(type.GetGenericTypeDefinition()).ReferenceFrom(targetUnit, typeGenerator); var arguments = new List <TypeScriptType>(); foreach (var argument in type.GetGenericArguments()) { var targetType = typeGenerator.ResolveType(argument).ReferenceFrom(targetUnit, typeGenerator); arguments.Add(targetType is INullabilityWrapperType nullabilityType ? nullabilityType.InnerType : targetType); } return(new TypeScriptGenericTypeReference(typeReference as TypeScriptTypeReference, arguments.ToArray())); }
public override void Initialize(ITypeGenerator typeGenerator) { Declaration = CreateComplexTypeScriptDeclarationWithoutDefinition(Type); Unit.Body.Add(new TypeScriptExportTypeStatement { Declaration = Declaration }); if (Type.BaseType != typeof(object) && Type.BaseType != typeof(ValueType) && Type.BaseType != typeof(MarshalByRefObject) && Type.BaseType != null) { typeGenerator.ResolveType(Type.BaseType); } }
public TypeScriptTypeMemberDeclaration?ResolveProperty(TypeScriptUnit unit, ITypeGenerator typeGenerator, ITypeInfo typeInfo, IPropertyInfo propertyInfo) { if (!TryGetGetOnlyEnumPropertyValue(typeInfo, propertyInfo, out var value)) { return(null); } return(new TypeScriptTypeMemberDeclaration { Name = propertyInfo.Name.ToLowerCamelCase(), Optional = false, Type = GetConstEnumType(typeGenerator, unit, propertyInfo, value !), });
public TypeScriptTypeMemberDeclaration ResolveProperty(TypeScriptUnit unit, ITypeGenerator typeGenerator, Type type, PropertyInfo property) { if (type == typeof(EnumWithConstGetterContainingRootType) && property.PropertyType.IsEnum && !property.CanWrite) { return(new TypeScriptTypeMemberDeclaration { Name = property.Name.ToLowerCamelCase(), Optional = false, Type = new TypeScriptStringLiteralType(property.GetMethod.Invoke(Activator.CreateInstance(type), null).ToString()), }); } return(null); }
private static TypeScriptType GetConstEnumType(ITypeGenerator typeGenerator, TypeScriptUnit unit, PropertyInfo property, string value) { switch (typeGenerator.Options.EnumGenerationMode) { case EnumGenerationMode.FixedStringsAndDictionary: return(new TypeScriptStringLiteralType(value)); case EnumGenerationMode.TypeScriptEnum: return(new TypeScriptEnumValueType(typeGenerator.BuildAndImportType(unit, property, property.PropertyType), value)); default: throw new ArgumentOutOfRangeException(); } }
public override void Initialize(ITypeGenerator typeGenerator) { Declaration = CreateComplexTypeScriptDeclarationWithoutDefinition(Type); Unit.Body.Add(new TypeScriptExportTypeStatement { Declaration = Declaration }); var baseType = Type.BaseType; if (baseType != null && !baseType.Equals(TypeInfo.From <object>()) && !baseType.Equals(TypeInfo.From <ValueType>()) && !baseType.Equals(TypeInfo.From <MarshalByRefObject>())) { typeGenerator.ResolveType(baseType); } }
protected virtual IEnumerable <MemberDeclarationSyntax> GenerateAdditionalPropertiesMember( ILocatedOpenApiElement <OpenApiSchema> additionalProperties) { // The AdditionalProperties element isn't generated here, it's done by the AdditionalPropertiesEnricher // However, we do need to generate the schema now ITypeGenerator schemaGenerator = Context.TypeGeneratorRegistry.Get(additionalProperties); if (schemaGenerator.TypeInfo.IsGenerated && additionalProperties.Element.Reference == null) { foreach (MemberDeclarationSyntax childTypeDeclaration in schemaGenerator.Generate()) { yield return(childTypeDeclaration); } } }
public TypeScriptTypeMemberDeclaration ResolveProperty(TypeScriptUnit unit, ITypeGenerator typeGenerator, Type type, PropertyInfo property) { var(isNullable, _) = TypeScriptGeneratorHelpers.ProcessNullable(property, property.PropertyType, typeGenerator.Options.NullabilityMode); if (!TryGetGetOnlyEnumPropertyValue(type, property, out var value)) { return(null); } return(new TypeScriptTypeMemberDeclaration { Name = property.Name.ToLowerCamelCase(), Optional = isNullable && typeGenerator.Options.EnableOptionalProperties, Type = GetConstEnumType(typeGenerator, unit, property, value), }); }
public override void Initialize(ITypeGenerator typeGenerator) { var types = Type.Assembly .GetTypes() .Where(x => x.BaseType != null && x.BaseType.Equals(Type)) .ToArray(); Declaration = new TypeScriptTypeDeclaration { Name = Type.Name, Definition = new TypeScriptUnionType( types.Select(x => typeGenerator.BuildAndImportType(Unit, x).NotNull()).ToArray() ) }; base.Initialize(typeGenerator); }
private static ImmutableArray <ITypeParameterSymbol> RenameTypeParameters( ImmutableArray <ITypeParameterSymbol> typeParameters, ImmutableArray <string> newNames, ITypeGenerator typeGenerator ) { // We generate the type parameter in two passes. The first creates the new type // parameter. The second updates the constraints to point at this new type parameter. var newTypeParameters = new List <CodeGenerationTypeParameterSymbol>(); var mapping = new Dictionary <ITypeSymbol, ITypeSymbol>(SymbolEqualityComparer.Default); for (var i = 0; i < typeParameters.Length; i++) { var typeParameter = typeParameters[i]; var newTypeParameter = new CodeGenerationTypeParameterSymbol( typeParameter.ContainingType, typeParameter.GetAttributes(), typeParameter.Variance, newNames[i], typeParameter.NullableAnnotation, typeParameter.ConstraintTypes, typeParameter.HasConstructorConstraint, typeParameter.HasReferenceTypeConstraint, typeParameter.HasValueTypeConstraint, typeParameter.HasUnmanagedTypeConstraint, typeParameter.HasNotNullConstraint, typeParameter.Ordinal ); newTypeParameters.Add(newTypeParameter); mapping[typeParameter] = newTypeParameter; } // Now we update the constraints. foreach (var newTypeParameter in newTypeParameters) { newTypeParameter.ConstraintTypes = ImmutableArray.CreateRange( newTypeParameter.ConstraintTypes, t => t.SubstituteTypes(mapping, typeGenerator) ); } return(newTypeParameters.Cast <ITypeParameterSymbol>().ToImmutableArray()); }
protected virtual IEnumerable <MemberDeclarationSyntax> DeclareProperty( ILocatedOpenApiElement <OpenApiSchema> property, string ownerName) { yield return(CreatePropertyDeclaration(property, ownerName)); if (property.Element.Reference == null) { // This isn't a reference, so we must generate the child schema ITypeGenerator generator = Context.SchemaGeneratorRegistry.Get(property); foreach (MemberDeclarationSyntax child in generator.Generate()) { yield return(child); } } }
public StripLegacyResponse(ITypeGenerator typeGenerator) { _typeGenerator = typeGenerator; }
private static IList<ITypeParameterSymbol> RenameTypeParameters( IList<ITypeParameterSymbol> typeParameters, IList<string> newNames, ITypeGenerator typeGenerator) { // We generate the type parameter in two passes. The first creates the new type // parameter. The second updates the constraints to point at this new type parameter. var newTypeParameters = new List<CodeGenerationTypeParameterSymbol>(); var mapping = new Dictionary<ITypeSymbol, ITypeSymbol>(); for (int i = 0; i < typeParameters.Count; i++) { var typeParameter = typeParameters[i]; var newTypeParameter = new CodeGenerationTypeParameterSymbol( typeParameter.ContainingType, typeParameter.GetAttributes(), typeParameter.Variance, newNames[i], typeParameter.ConstraintTypes, typeParameter.HasConstructorConstraint, typeParameter.HasReferenceTypeConstraint, typeParameter.HasValueTypeConstraint, typeParameter.Ordinal); newTypeParameters.Add(newTypeParameter); mapping[typeParameter] = newTypeParameter; } // Now we update the constraints. foreach (var newTypeParameter in newTypeParameters) { newTypeParameter.ConstraintTypes = ImmutableArray.CreateRange(newTypeParameter.ConstraintTypes, t => t.SubstituteTypes(mapping, typeGenerator)); } return newTypeParameters.Cast<ITypeParameterSymbol>().ToList(); }
protected RecordReference(ITypeGenerator typeGenerator, IAttributeDecorator attributeDecorator) { this.TypeGenerator = typeGenerator; this.AttributeDecorator = attributeDecorator; }