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;
}
