protected static IEnumerable <string> GetStartingPhrases(ITypeSymbol symbolReturnType, string[] startingPhrases)
{
var returnType = symbolReturnType.ToString();
var returnTypeFullyQualified = symbolReturnType.FullyQualifiedName();
if (returnTypeFullyQualified.Contains('.') is false)
{
returnTypeFullyQualified = symbolReturnType.FullyQualifiedName(false);
}
symbolReturnType.TryGetGenericArgumentCount(out var count);
if (count <= 0)
{
return(Enumerable.Empty <string>()
.Concat(startingPhrases.Select(_ => string.Format(_, returnType)))
.Concat(startingPhrases.Select(_ => string.Format(_, returnTypeFullyQualified))));
}
var ts = symbolReturnType.GetGenericArgumentsAsTs();
var length = returnType.IndexOf('<'); // just until the first one
var returnTypeWithTs = returnType.Substring(0, length) + "{" + ts + "}";
var returnTypeWithGenericCount = returnType.Substring(0, length) + '`' + count;
return(Enumerable.Empty <string>()
.Concat(startingPhrases.Select(_ => string.Format(_, returnTypeWithTs))) // for the phrases to show to the user
.Concat(startingPhrases.Select(_ => string.Format(_, returnTypeWithGenericCount)))); // for the real check
}
public static string ReflectionTypeName(this ITypeSymbol type, out IList <string> typeParameters)
{
if (type is INamedTypeSymbol namedType && namedType.IsGenericType) //TODO: namedType.IsUnboundGenericType ? Open
{
typeParameters = namedType.TypeArguments.Select(typeArg => typeArg.FullyQualifiedName()).ToArray();
return(Regex.Replace(namedType.ConstructedFrom.ToString(), "<.*>", "`" + namedType.TypeArguments.Length));
}
typeParameters = Array.Empty <string>();
return(type.FullyQualifiedName());
}
public static TypeSyntax GenerateTypeSyntax(ITypeSymbol type, SemanticModel model, int pos, SharpSixRewriter rewriter)
{
if (type.IsTupleType)
{
var elements = ((INamedTypeSymbol)type).TupleElements;
var types = new List <TypeSyntax>();
foreach (var el in elements)
{
types.Add(SyntaxHelper.GenerateTypeSyntax(el.Type, model, pos, rewriter));
}
return(SyntaxFactory.GenericName(SyntaxFactory.Identifier("System.ValueTuple"), SyntaxFactory.TypeArgumentList(SyntaxFactory.SeparatedList <TypeSyntax>(types))));
}
var typeName = type.FullyQualifiedName(false);
if (rewriter.usingStaticNames.Any(n => typeName.StartsWith(n + '.')))
{
return(SyntaxFactory.ParseTypeName(type.ToDisplayString()));
}
else if (type is INamedTypeSymbol namedType && namedType.IsGenericType)
{
var elements = namedType.TypeArguments;
var types = new List <TypeSyntax>();
foreach (var el in elements)
{
types.Add(SyntaxHelper.GenerateTypeSyntax(el, model, pos, rewriter));
}
return(SyntaxFactory.GenericName(
SyntaxFactory.Identifier(
type.ToMinimalDisplayString(
model,
pos,
new SymbolDisplayFormat(
genericsOptions: SymbolDisplayGenericsOptions.None
)
)
),
SyntaxFactory.TypeArgumentList(
SyntaxFactory.SeparatedList <TypeSyntax>(types)
)
));
}
return(SyntaxFactory.ParseTypeName(type.ToMinimalDisplayString(model, pos)));
}
public static string ResolveExpression(this ITypeSymbol type, IVisitorContext ctx)
{
if (type.IsDefinedInCurrentType(ctx))
{
//TODO: This assumes the type in question as already been visited.
// see: Types\ForwardTypeReference
return(ctx.DefinitionVariables.GetTypeVariable(type.Name).VariableName);
}
string typeName;
if (type is INamedTypeSymbol namedType)
{
var genTypeName = Regex.Replace(namedType.ConstructedFrom.ToString(), "<.*>", "<" + new string(',', namedType.TypeArguments.Length - 1) + ">");
typeName = genTypeName;
}
else
{
typeName = type.FullyQualifiedName();
}
return(ImportFromMainModule($"TypeHelpers.ResolveType(\"{type.ContainingAssembly.Name}\", \"{typeName}\")"));
}
protected void HandlePotentialDelegateInvocationOn(SimpleNameSyntax node, ITypeSymbol typeSymbol, string ilVar)
{
var invocation = node.Parent as InvocationExpressionSyntax;
if (invocation == null || invocation.Expression != node)
{
return;
}
var localDelegateDeclaration = Context.TypeResolver.ResolveTypeLocalVariable(typeSymbol.Name);
if (localDelegateDeclaration != null)
{
AddCilInstruction(ilVar, OpCodes.Callvirt, $"{localDelegateDeclaration}.Methods.Single(m => m.Name == \"Invoke\")");
}
else
{
var declaringTypeName = typeSymbol.FullyQualifiedName();
var methodInvocation = ImportFromMainModule($"TypeHelpers.ResolveMethod(\"{typeSymbol.ContainingAssembly.Name}\", \"{declaringTypeName}\", \"Invoke\")");
AddCilInstruction(ilVar, OpCodes.Callvirt, methodInvocation);
}
}
private static bool TypeMatches(ITypeSymbol symbol, string type) => symbol.FullyQualifiedName().Equals(type);
public static bool HasMethod(
this ITypeSymbol symbol, ITypeSymbol?returnType, string name, params ITypeSymbol[] parameters) =>
HasMethodImpl(symbol, returnType?.FullyQualifiedName(), name,
parameters.Select(i => i.FullyQualifiedName()).ToArray());
public static void WriteTypeSymbolName(this CodeWriter writer, ITypeSymbol symbol)
{
writer.Append(symbol.FullyQualifiedName());
}
public static TypeSyntax GenerateTypeSyntax(ITypeSymbol type, SemanticModel model, int pos, SharpSixRewriter rewriter)
{
if (type.IsTupleType)
{
var elements = ((INamedTypeSymbol)type).TupleElements;
var types = new List <TypeSyntax>();
foreach (var el in elements)
{
types.Add(SyntaxHelper.GenerateTypeSyntax(el.Type, model, pos, rewriter));
}
return(SyntaxFactory.GenericName(SyntaxFactory.Identifier("System.ValueTuple"), SyntaxFactory.TypeArgumentList(SyntaxFactory.SeparatedList <TypeSyntax>(types))));
}
var typeName = type.FullyQualifiedName(false);
if (rewriter.usingStaticNames.Any(n => typeName.StartsWith(n + '.')))
{
return(SyntaxFactory.ParseTypeName(type.ToDisplayString()));
}
else if (type is INamedTypeSymbol namedType && namedType.IsGenericType)
{
var elements = namedType.TypeArguments;
var types = new List <TypeSyntax>();
foreach (var el in elements)
{
types.Add(SyntaxHelper.GenerateTypeSyntax(el, model, pos, rewriter));
}
if (type.OriginalDefinition != null && type.OriginalDefinition.SpecialType == SpecialType.System_Nullable_T)
{
return(SyntaxFactory.IdentifierName(type.ToMinimalDisplayString(
model,
pos,
new SymbolDisplayFormat(
genericsOptions: SymbolDisplayGenericsOptions.None
)
)));
}
if (types.Count > 0)
{
string gtypeName;
if (type.ContainingType != null)
{
var parent = SyntaxHelper.GenerateTypeSyntax(type.ContainingType, model, pos, rewriter);
var name = type.Name;
gtypeName = SyntaxFactory.QualifiedName((NameSyntax)parent, SyntaxFactory.IdentifierName(name)).ToString();
}
else
{
gtypeName = type.ToMinimalDisplayString(
model,
pos,
new SymbolDisplayFormat(
genericsOptions: SymbolDisplayGenericsOptions.None
)
);
}
if (model != null)
{
var ai = model.GetSpeculativeAliasInfo(pos, SyntaxFactory.IdentifierName(gtypeName), SpeculativeBindingOption.BindAsTypeOrNamespace);
if (ai != null && ai.Name == gtypeName)
{
return(SyntaxFactory.ParseTypeName(gtypeName));
}
}
return(SyntaxFactory.GenericName(
SyntaxFactory.Identifier(gtypeName),
SyntaxFactory.TypeArgumentList(
SyntaxFactory.SeparatedList <TypeSyntax>(types)
)
));
}
}
if (type.ContainingType != null && type.Kind != SymbolKind.TypeParameter)
{
var parent = SyntaxHelper.GenerateTypeSyntax(type.ContainingType, model, pos, rewriter);
var name = type.Name;
return(SyntaxFactory.QualifiedName((NameSyntax)parent, SyntaxFactory.IdentifierName(name)));
}
return(SyntaxFactory.ParseTypeName(type.ToMinimalDisplayString(model, pos)));
}
