private static TypeSyntax GenerateTypeSyntax(
INamespaceOrTypeSymbol symbol, bool nameSyntax, bool allowVar = true)
{
var type = symbol as ITypeSymbol;
if (type != null && type.ContainsAnonymousType())
{
// something with an anonymous type can only be represented with 'var', regardless
// of what the user's preferences might be.
return(SyntaxFactory.IdentifierName("var"));
}
var syntax = symbol.Accept(TypeSyntaxGeneratorVisitor.Create(nameSyntax))
.WithAdditionalAnnotations(Simplifier.Annotation);
if (!allowVar)
{
syntax = syntax.WithAdditionalAnnotations(DoNotAllowVarAnnotation.Annotation);
}
#if !CODE_STYLE
if (type != null && type.IsReferenceType)
{
syntax = syntax.WithAdditionalAnnotations(
type.NullableAnnotation switch
{
NullableAnnotation.None => NullableSyntaxAnnotation.Oblivious,
NullableAnnotation.Annotated => NullableSyntaxAnnotation.AnnotatedOrNotAnnotated,
NullableAnnotation.NotAnnotated => NullableSyntaxAnnotation.AnnotatedOrNotAnnotated,
_ => throw ExceptionUtilities.UnexpectedValue(type.NullableAnnotation),
});
public override ExpressionSyntax VisitNamedType(INamedTypeSymbol symbol)
{
if (
TypeSyntaxGeneratorVisitor.TryCreateNativeIntegerType(
symbol,
out var typeSyntax
)
)
{
return(typeSyntax);
}
typeSyntax = TypeSyntaxGeneratorVisitor.Create().CreateSimpleTypeSyntax(symbol);
if (!(typeSyntax is SimpleNameSyntax))
{
return(typeSyntax);
}
var simpleNameSyntax = (SimpleNameSyntax)typeSyntax;
if (symbol.ContainingType != null)
{
if (symbol.ContainingType.TypeKind == TypeKind.Submission)
{
return(simpleNameSyntax);
}
else
{
var container = symbol.ContainingType.Accept(this) !;
return(CreateMemberAccessExpression(symbol, container, simpleNameSyntax));
}
}
else if (symbol.ContainingNamespace != null)
{
if (symbol.ContainingNamespace.IsGlobalNamespace)
{
if (symbol.TypeKind != TypeKind.Error)
{
return(AddInformationTo(
SyntaxFactory.AliasQualifiedName(
SyntaxFactory.IdentifierName(
SyntaxFactory.Token(SyntaxKind.GlobalKeyword)
),
simpleNameSyntax
),
symbol
));
}
}
else
{
var container = symbol.ContainingNamespace.Accept(this) !;
return(CreateMemberAccessExpression(symbol, container, simpleNameSyntax));
}
}
return(simpleNameSyntax);
}
private static TypeSyntax GenerateTypeSyntax(
INamespaceOrTypeSymbol symbol, bool nameSyntax, bool allowVar = true)
{
var syntax = symbol.Accept(TypeSyntaxGeneratorVisitor.Create(nameSyntax))
.WithAdditionalAnnotations(Simplifier.Annotation);
if (!allowVar)
{
syntax = syntax.WithAdditionalAnnotations(DoNotAllowVarAnnotation.Annotation);
}
return(syntax);
}
private static TypeSyntax GenerateTypeSyntax(
INamespaceOrTypeSymbol symbol, bool nameSyntax, bool allowVar = true)
{
if (symbol is ITypeSymbol type && type.ContainsAnonymousType())
{
// something with an anonymous type can only be represented with 'var', regardless
// of what the user's preferences might be.
return(SyntaxFactory.IdentifierName("var"));
}
var syntax = symbol.Accept(TypeSyntaxGeneratorVisitor.Create(nameSyntax))
.WithAdditionalAnnotations(Simplifier.Annotation);
if (!allowVar)
{
syntax = syntax.WithAdditionalAnnotations(DoNotAllowVarAnnotation.Annotation);
}
return(syntax);
}
private static TypeSyntax GenerateTypeSyntax(
INamespaceOrTypeSymbol symbol, bool nameSyntax)
{
return(symbol.Accept(TypeSyntaxGeneratorVisitor.Create(nameSyntax))
.WithAdditionalAnnotations(Simplifier.Annotation));
}
public override ExpressionSyntax DefaultVisit(ISymbol symbol) => symbol.Accept(TypeSyntaxGeneratorVisitor.Create());
