public static string GetTrackerClassName(TypeSyntax type)
{
// NOTE: it's naive approach because we don't know semantic type information here.
var genericType = type as GenericNameSyntax;
if (genericType == null)
{
if (type.ToString().StartsWith("Trackable"))
{
return $"TrackablePocoTracker<I{type.ToString().Substring(9)}>";
}
}
else if (CodeAnalaysisExtensions.CompareTypeName(genericType.Identifier.ToString(),
"TrackableData.TrackableDictionary"))
{
return $"TrackableDictionaryTracker{genericType.TypeArgumentList}";
}
else if (CodeAnalaysisExtensions.CompareTypeName(genericType.Identifier.ToString(),
"TrackableData.TrackableSet"))
{
return $"TrackableSetTracker{genericType.TypeArgumentList}";
}
else if (CodeAnalaysisExtensions.CompareTypeName(genericType.Identifier.ToString(),
"TrackableData.TrackableList"))
{
return $"TrackableListTracker{genericType.TypeArgumentList}";
}
throw new Exception("Cannot resolve tracker class of " + type);
}
public static TRoot ReplaceType <TRoot>(this TRoot node, TypeSyntax type) where TRoot : SyntaxNode
{
string value = HlslKnownTypes.GetMappedName(type.ToString());
// If the HLSL mapped full type name equals the original type, just return the input node
if (value == type.ToString())
{
return(node);
}
// Process and return the type name
TypeSyntax newType = SyntaxFactory.ParseTypeName(value).WithLeadingTrivia(type.GetLeadingTrivia()).WithTrailingTrivia(type.GetTrailingTrivia());
return(node.ReplaceNode(type, newType));
}
public static glsl.TypeSyntax Translate(this cs.TypeSyntax node)
{
return(new glsl.TypeSyntax()
{
Name = node.ToString()
});
}
public static bool IsTrackableType(TypeSyntax type)
{
// NOTE: it's naive approach because we don't know semantic type information here.
var parts = type.ToString().Split('.');
var typeName = parts[parts.Length - 1];
return typeName.StartsWith("Trackable");
}
public static string GetFieldVariableName(TypeSyntax type, bool underscore)
{
var name = type.ToString();
if (name.StartsWith("I"))
name = name.Substring(1);
var firstChara = name[0];
if (Char.IsUpper(firstChara))
{
name = firstChara.ToString().ToLower() + name.Substring(1);
}
else
{
name += 1;
}
return name;
}
private static string ResolveLType(TypeSyntax node)
{
var gensyn = node as GenericNameSyntax;
if (null != gensyn) return gensyn.Identifier.ToString();
else return node.ToString();
}
/// <remarks>
/// Keep in sync with <see cref="M:SemanticModel.GetSpeculativelyBoundExpression()"/>.
/// </remarks>
private TypeSymbol BindCrefParameterOrReturnType(TypeSyntax typeSyntax, MemberCrefSyntax memberCrefSyntax, DiagnosticBag diagnostics)
{
DiagnosticBag unusedDiagnostics = DiagnosticBag.GetInstance(); // Examined, but not reported.
// After much deliberation, we eventually decided to suppress lookup of inherited members within
// crefs, in order to match dev11's behavior (Changeset #829014). Unfortunately, it turns out
// that dev11 does not suppress these members when performing lookup within parameter and return
// types, within crefs (DevDiv #586815, #598371).
Debug.Assert(InCrefButNotParameterOrReturnType);
Binder parameterOrReturnTypeBinder = this.WithAdditionalFlags(BinderFlags.CrefParameterOrReturnType);
// It would be nice to pull this binder out of the factory so we wouldn't have to worry about them getting out
// of sync, but this code is also used for included crefs, which don't have BinderFactories.
// As a compromise, we'll assert that the binding locations match in scenarios where we can go through the factory.
Debug.Assert(!this.Compilation.ContainsSyntaxTree(typeSyntax.SyntaxTree) ||
this.Compilation.GetBinderFactory(typeSyntax.SyntaxTree).GetBinder(typeSyntax).Flags ==
(parameterOrReturnTypeBinder.Flags & ~BinderFlags.SemanticModel));
TypeSymbol type = parameterOrReturnTypeBinder.BindType(typeSyntax, unusedDiagnostics);
if (unusedDiagnostics.HasAnyErrors())
{
if (HasNonObsoleteError(unusedDiagnostics))
{
ErrorCode code = typeSyntax.Parent.Kind == SyntaxKind.ConversionOperatorMemberCref
? ErrorCode.WRN_BadXMLRefReturnType
: ErrorCode.WRN_BadXMLRefParamType;
CrefSyntax crefSyntax = GetRootCrefSyntax(memberCrefSyntax);
diagnostics.Add(code, typeSyntax.Location, typeSyntax.ToString(), crefSyntax.ToString());
}
}
else
{
Debug.Assert(type.TypeKind != TypeKind.Error || typeSyntax.ContainsDiagnostics || !typeSyntax.SyntaxTree.ReportDocumentationCommentDiagnostics(), "Why wasn't there a diagnostic?");
}
unusedDiagnostics.Free();
return type;
}
private static string GetTypeScriptEquivalentType(TypeSyntax field)
{
var type = "";
switch (field.ToString().ToLower())
{
case "int":
case "float":
case "small":
case "bigint":
type = "number";
break;
default:
type = field.ToString();
break;
}
return type;
}
private string GetMappedType(TypeSyntax type)
{
if (type.ToString() == "void")
return "void";
if (type.ToString().EndsWith("Exception"))
return type.ToString();
return type.ToString().StartsWith("int") ? "number" : "string";
}
// The "target = new Class1()" portion of "Class1 target = new Class1();"
private VariableDeclarationSyntax BuildVariableDeclaration(TypeSyntax variableType, string variableName)
{
return SyntaxFactory.VariableDeclaration(variableType,
SyntaxFactory.SingletonSeparatedList<VariableDeclaratorSyntax>(
SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(SyntaxFactory.TriviaList(), variableName, SyntaxFactory.TriviaList(SyntaxFactory.Space)))
.WithInitializer(
SyntaxFactory.EqualsValueClause(
SyntaxFactory.ObjectCreationExpression(SyntaxFactory.IdentifierName(variableType.ToString()))
.WithNewKeyword(SyntaxFactory.Token(SyntaxFactory.TriviaList(SyntaxFactory.Space), SyntaxKind.NewKeyword, SyntaxFactory.TriviaList(SyntaxFactory.Space)))
.WithArgumentList(SyntaxFactory.ArgumentList())
)
)
)
);
}
private string GetName(TypeSyntax name)
{
return (name as SimpleNameSyntax).Identifier.ToString() ?? name.ToString();
}
private string GetFullReturnType(TypeSyntax returnType)
{
var fullReturnType = returnType.ToString();
var node = returnType.DescendantNodes().OfType<IdentifierNameSyntax>().FirstOrDefault();
Document cl = null;
var systemTypes = new List<string>()
{
"Guid",
"Guid?"
};
if (node != null && systemTypes.All(x => x != node.Identifier.ToString() && x != returnType.ToString()))
{
var nameSpace = SymbolFinder.FindDeclarationsAsync(_project, node.Identifier.ValueText, ignoreCase: false).Result.Last().ContainingNamespace.ToString();
fullReturnType = fullReturnType.Replace(node.Identifier.ToString(), nameSpace + "." + node.Identifier);
}
return fullReturnType;
}
public TypeInspector(TypeSyntax typeSyntax)
{
ShortName = typeSyntax.ToString();
}
