IType SearchType(KnownTypeCode typeCode)
{
KnownTypeReference typeRef = KnownTypeReference.Get(typeCode);
if (typeRef == null)
{
return(SpecialType.UnknownType);
}
ITypeDefinition typeDef;
foreach (IAssembly asm in compilation.ReferencedAssemblies)
{
typeDef = asm.GetTypeDefinition(typeRef.Namespace, typeRef.Name, typeRef.TypeParameterCount);
if (typeDef != null)
{
return(typeDef);
}
}
typeDef = compilation.MainAssembly.GetTypeDefinition(typeRef.Namespace, typeRef.Name, typeRef.TypeParameterCount);
if (typeDef != null)
{
return(typeDef);
}
else
{
return(new UnknownType(typeRef.Namespace, typeRef.Name, typeRef.TypeParameterCount));
}
}
private MinimalCorlib() : base("corlib")
{
var types = new DefaultUnresolvedTypeDefinition[KnownTypeReference.KnownTypeCodeCount];
for (int i = 0; i < types.Length; i++)
{
var typeRef = KnownTypeReference.Get((KnownTypeCode)i);
if (typeRef != null)
{
types[i] = new DefaultUnresolvedTypeDefinition(typeRef.Namespace, typeRef.Name);
for (int j = 0; j < typeRef.TypeParameterCount; j++)
{
types[i].TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, j));
}
AddTypeDefinition(types[i]);
}
}
for (int i = 0; i < types.Length; i++)
{
var typeRef = KnownTypeReference.Get((KnownTypeCode)i);
if (typeRef != null && typeRef.baseType != KnownTypeCode.None)
{
types[i].BaseTypes.Add(types[(int)typeRef.baseType]);
if (typeRef.baseType == KnownTypeCode.ValueType && i != (int)KnownTypeCode.Enum)
{
types[i].Kind = TypeKind.Struct;
}
}
}
Freeze();
}
SearchScope FindObjectCreateReferences(IMethod ctor)
{
ctor = (IMethod)ctor.MemberDefinition;
string searchTerm = null;
if (KnownTypeReference.GetCSharpNameByTypeCode(ctor.DeclaringTypeDefinition.KnownTypeCode) == null)
{
// not a built-in type
searchTerm = ctor.DeclaringTypeDefinition.Name;
if (searchTerm.Length > 9 && searchTerm.EndsWith("Attribute", StringComparison.Ordinal))
{
// we also need to look for the short form
searchTerm = null;
}
}
return(new SearchScope(
searchTerm,
delegate(ICompilation compilation) {
IMethod imported = compilation.Import(ctor);
if (imported != null)
{
return new FindObjectCreateReferencesNavigator(imported);
}
else
{
return null;
}
}));
}
public CorlibTypeDefinition(MinimalCorlib corlib, KnownTypeCode typeCode)
{
this.corlib = corlib;
this.typeCode = typeCode;
KnownTypeReference ktr = KnownTypeReference.Get(typeCode);
this.typeKind = ktr.typeKind;
this.MetadataName = ktr.Name + (ktr.TypeParameterCount > 0 ? "`" + ktr.TypeParameterCount : "");
}
protected AstType ConvertType(KnownTypeCode knownTypeCode)
{
IType type = refactoringContext.Compilation.FindType(knownTypeCode);
if (type != null)
{
return(ConvertType(type));
}
// Backup solution
return(new SimpleType(KnownTypeReference.GetCSharpNameByTypeCode(knownTypeCode)));
}
public RequiredNamespaceCollector(HashSet <string> namespaces)
{
this.namespaces = namespaces;
for (int i = 0; i < KnownTypeReference.KnownTypeCodeCount; i++)
{
var ktr = KnownTypeReference.Get((KnownTypeCode)i);
if (ktr == null)
{
continue;
}
namespaces.Add(ktr.Namespace);
}
}
public override ITypeReference ToTypeReference(NameLookupMode lookupMode, InterningProvider interningProvider = null)
{
KnownTypeCode typeCode = GetTypeCodeForPrimitiveType(this.Keyword);
if (typeCode == KnownTypeCode.None)
{
return(new UnknownType(null, this.Keyword));
}
else
{
return(KnownTypeReference.Get(typeCode));
}
}
private MinimalCorlib(ICompilation compilation)
{
this.Compilation = compilation;
this.typeDefinitions = new CorlibTypeDefinition[KnownTypeReference.KnownTypeCodeCount];
this.rootNamespace = new CorlibNamespace(this, null, string.Empty, string.Empty);
for (int i = 0; i < KnownTypeReference.KnownTypeCodeCount; i++)
{
if (KnownTypeReference.Get((KnownTypeCode)i) != null)
{
typeDefinitions[i] = new CorlibTypeDefinition(this, (KnownTypeCode)i);
}
}
}
public override ITypeReference ToTypeReference(SimpleNameLookupMode lookupMode = SimpleNameLookupMode.Type)
{
KnownTypeCode typeCode = GetTypeCodeForPrimitiveType(this.Keyword);
if (typeCode == KnownTypeCode.None)
{
return(new UnknownType(null, this.Keyword));
}
else
{
return(KnownTypeReference.Get(typeCode));
}
}
SearchScope FindTypeDefinitionReferences(ITypeDefinition typeDefinition, bool findTypeReferencesEvenIfAliased, out SearchScope additionalScope)
{
string searchTerm = null;
additionalScope = null;
if (!findTypeReferencesEvenIfAliased && KnownTypeReference.GetCSharpNameByTypeCode(typeDefinition.KnownTypeCode) == null)
{
// We can optimize the search by looking only for the type references with the right identifier,
// but only if it's not a primitive type and we're not looking for indirect references (through an alias)
searchTerm = typeDefinition.Name;
if (searchTerm.Length > 9 && searchTerm.EndsWith("Attribute", StringComparison.Ordinal))
{
// The type might be an attribute, so we also need to look for the short form:
string shortForm = searchTerm.Substring(0, searchTerm.Length - 9);
additionalScope = new SearchScope(
shortForm,
delegate(ICompilation compilation) {
ITypeDefinition imported = compilation.Import(typeDefinition);
if (imported != null)
{
return(new FindTypeDefinitionReferencesNavigator(imported, shortForm));
}
else
{
return(null);
}
});
}
}
return(new SearchScope(
searchTerm,
delegate(ICompilation compilation) {
ITypeDefinition imported = compilation.Import(typeDefinition);
if (imported != null)
{
return new FindTypeDefinitionReferencesNavigator(imported, searchTerm);
}
else
{
return null;
}
}));
}
IType SearchType(KnownTypeCode typeCode)
{
KnownTypeReference typeRef = KnownTypeReference.Get(typeCode);
if (typeRef == null)
{
return(SpecialType.UnknownType);
}
var typeName = new TopLevelTypeName(typeRef.Namespace, typeRef.Name, typeRef.TypeParameterCount);
foreach (IAssembly asm in compilation.Assemblies)
{
var typeDef = asm.GetTypeDefinition(typeName);
if (typeDef != null)
{
return(typeDef);
}
}
return(new UnknownType(typeName));
}
public static bool IsKnownType(this EntityHandle handle, MetadataReader reader,
KnownTypeCode knownType)
{
return(!handle.IsNil &&
GetFullTypeName(handle, reader) == KnownTypeReference.Get(knownType).TypeName);
}
AstType ConvertTypeHelper(ITypeDefinition typeDef, IList <IType> typeArguments)
{
Debug.Assert(typeArguments.Count >= typeDef.TypeParameterCount);
string keyword = KnownTypeReference.GetCSharpNameByTypeCode(typeDef.KnownTypeCode);
if (keyword != null)
{
return(new PrimitiveType(keyword));
}
// The number of type parameters belonging to outer classes
int outerTypeParameterCount;
if (typeDef.DeclaringType != null)
{
outerTypeParameterCount = typeDef.DeclaringType.TypeParameterCount;
}
else
{
outerTypeParameterCount = 0;
}
if (resolver != null)
{
// Look if there's an alias to the target type
if (UseAliases)
{
for (ResolvedUsingScope usingScope = resolver.CurrentUsingScope; usingScope != null; usingScope = usingScope.Parent)
{
foreach (var pair in usingScope.UsingAliases)
{
if (pair.Value is TypeResolveResult)
{
if (TypeMatches(pair.Value.Type, typeDef, typeArguments))
{
return(new SimpleType(pair.Key));
}
}
}
}
}
IList <IType> localTypeArguments;
if (typeDef.TypeParameterCount > outerTypeParameterCount)
{
localTypeArguments = new IType[typeDef.TypeParameterCount - outerTypeParameterCount];
for (int i = 0; i < localTypeArguments.Count; i++)
{
localTypeArguments[i] = typeArguments[outerTypeParameterCount + i];
}
}
else
{
localTypeArguments = EmptyList <IType> .Instance;
}
ResolveResult rr = resolver.ResolveSimpleName(typeDef.Name, localTypeArguments);
TypeResolveResult trr = rr as TypeResolveResult;
if (trr != null || (localTypeArguments.Count == 0 && resolver.IsVariableReferenceWithSameType(rr, typeDef.Name, out trr)))
{
if (!trr.IsError && TypeMatches(trr.Type, typeDef, typeArguments))
{
// We can use the short type name
SimpleType shortResult = new SimpleType(typeDef.Name);
AddTypeArguments(shortResult, typeDef, typeArguments, outerTypeParameterCount, typeDef.TypeParameterCount);
return(shortResult);
}
}
}
if (AlwaysUseShortTypeNames)
{
var shortResult = new SimpleType(typeDef.Name);
AddTypeArguments(shortResult, typeDef, typeArguments, outerTypeParameterCount, typeDef.TypeParameterCount);
return(shortResult);
}
MemberType result = new MemberType();
if (typeDef.DeclaringTypeDefinition != null)
{
// Handle nested types
result.Target = ConvertTypeHelper(typeDef.DeclaringTypeDefinition, typeArguments);
}
else
{
// Handle top-level types
if (string.IsNullOrEmpty(typeDef.Namespace))
{
result.Target = new SimpleType("global");
result.IsDoubleColon = true;
}
else
{
result.Target = ConvertNamespace(typeDef.Namespace);
}
}
result.MemberName = typeDef.Name;
AddTypeArguments(result, typeDef, typeArguments, outerTypeParameterCount, typeDef.TypeParameterCount);
return(result);
}
void FormatLineInternal(ITextEditor textArea, int lineNr, int cursorOffset, char ch)
{
IDocumentLine curLine = textArea.Document.GetLineByNumber(lineNr);
IDocumentLine lineAbove = lineNr > 1 ? textArea.Document.GetLineByNumber(lineNr - 1) : null;
string terminator = DocumentUtilities.GetLineTerminator(textArea.Document, lineNr);
string curLineText;
// local string for curLine segment
if (ch == '/')
{
curLineText = textArea.Document.GetText(curLine);
string lineAboveText = lineAbove == null ? "" : textArea.Document.GetText(lineAbove);
if (curLineText != null && curLineText.EndsWith("///", StringComparison.Ordinal) && (lineAboveText == null || !lineAboveText.Trim().StartsWith("///", StringComparison.Ordinal)))
{
string indentation = DocumentUtilities.GetWhitespaceAfter(textArea.Document, curLine.Offset);
IUnresolvedEntity member = GetMemberAfter(textArea, lineNr);
if (member != null)
{
StringBuilder sb = new StringBuilder();
sb.Append(" <summary>");
sb.Append(terminator);
sb.Append(indentation);
sb.Append("/// ");
sb.Append(terminator);
sb.Append(indentation);
sb.Append("/// </summary>");
IUnresolvedMethod method = null;
if (member is IUnresolvedMethod)
{
method = (IUnresolvedMethod)member;
}
else if (member is IUnresolvedTypeDefinition)
{
IUnresolvedTypeDefinition type = (IUnresolvedTypeDefinition)member;
if (type.Kind == TypeKind.Delegate)
{
method = type.Methods.FirstOrDefault(m => m.Name == "Invoke");
}
}
if (method != null)
{
for (int i = 0; i < method.Parameters.Count; ++i)
{
sb.Append(terminator);
sb.Append(indentation);
sb.Append("/// <param name=\"");
sb.Append(method.Parameters[i].Name);
sb.Append("\"></param>");
}
if (!method.IsConstructor)
{
KnownTypeReference returnType = method.ReturnType as KnownTypeReference;
if (returnType == null || returnType.KnownTypeCode != KnownTypeCode.Void)
{
sb.Append(terminator);
sb.Append(indentation);
sb.Append("/// <returns></returns>");
}
}
}
textArea.Document.Insert(cursorOffset, sb.ToString());
textArea.Caret.Offset = cursorOffset + indentation.Length + "/// ".Length + " <summary>".Length + terminator.Length;
}
}
return;
}
if (ch != '\n' && ch != '>')
{
if (IsInsideStringOrComment(textArea, curLine, cursorOffset))
{
return;
}
}
switch (ch)
{
case '>':
if (IsInsideDocumentationComment(textArea, curLine, cursorOffset))
{
curLineText = textArea.Document.GetText(curLine);
int column = cursorOffset - curLine.Offset;
int index = Math.Min(column - 1, curLineText.Length - 1);
while (index >= 0 && curLineText[index] != '<')
{
--index;
if (curLineText[index] == '/')
{
return; // the tag was an end tag or already
}
}
if (index > 0)
{
StringBuilder commentBuilder = new StringBuilder("");
for (int i = index; i < curLineText.Length && i < column && !Char.IsWhiteSpace(curLineText[i]); ++i)
{
commentBuilder.Append(curLineText[i]);
}
string tag = commentBuilder.ToString().Trim();
if (!tag.EndsWith(">", StringComparison.Ordinal))
{
tag += ">";
}
if (!tag.StartsWith("/", StringComparison.Ordinal))
{
textArea.Document.Insert(cursorOffset, "</" + tag.Substring(1), AnchorMovementType.BeforeInsertion);
}
}
}
break;
case ':':
case ')':
case ']':
case '{':
//if (textArea.Document.TextEditorProperties.IndentStyle == IndentStyle.Smart) {
IndentLine(textArea, curLine);
//}
break;
case '}':
// Try to get corresponding block beginning brace
var bracketSearchResult = textArea.Language.BracketSearcher.SearchBracket(textArea.Document, cursorOffset);
if (bracketSearchResult != null)
{
// Format the block
if (!FormatStatement(textArea, cursorOffset, bracketSearchResult.OpeningBracketOffset))
{
// No auto-formatting seems to be active, at least indent the line
IndentLine(textArea, curLine);
}
}
break;
case ';':
// Format this line
if (!FormatStatement(textArea, cursorOffset, cursorOffset))
{
// No auto-formatting seems to be active, at least indent the line
IndentLine(textArea, curLine);
}
break;
case '\n':
string lineAboveText = lineAbove == null ? "" : textArea.Document.GetText(lineAbove);
// curLine might have some text which should be added to indentation
curLineText = textArea.Document.GetText(curLine);
if (lineAboveText != null && lineAboveText.Trim().StartsWith("#region", StringComparison.Ordinal) &&
NeedEndregion(textArea.Document))
{
textArea.Document.Insert(cursorOffset, "#endregion");
return;
}
IHighlighter highlighter = textArea.GetService(typeof(IHighlighter)) as IHighlighter;
bool isInMultilineComment = false;
bool isInMultilineString = false;
if (highlighter != null && lineAbove != null)
{
var spanStack = highlighter.GetColorStack(lineNr).Select(c => c.Name).ToArray();
isInMultilineComment = spanStack.Contains(HighlighterKnownSpanNames.Comment);
isInMultilineString = spanStack.Contains(HighlighterKnownSpanNames.String);
}
bool isInNormalCode = !(isInMultilineComment || isInMultilineString);
if (lineAbove != null && isInMultilineComment)
{
string lineAboveTextTrimmed = lineAboveText.TrimStart();
if (lineAboveTextTrimmed.StartsWith("/*", StringComparison.Ordinal))
{
textArea.Document.Insert(cursorOffset, " * ");
return;
}
if (lineAboveTextTrimmed.StartsWith("*", StringComparison.Ordinal))
{
textArea.Document.Insert(cursorOffset, "* ");
return;
}
}
if (lineAbove != null && isInNormalCode)
{
IDocumentLine nextLine = lineNr + 1 <= textArea.Document.LineCount ? textArea.Document.GetLineByNumber(lineNr + 1) : null;
string nextLineText = (nextLine != null) ? textArea.Document.GetText(nextLine) : "";
int indexAbove = lineAboveText.IndexOf("///", StringComparison.Ordinal);
int indexNext = nextLineText.IndexOf("///", StringComparison.Ordinal);
if (indexAbove > 0 && (indexNext != -1 || indexAbove + 4 < lineAbove.Length))
{
textArea.Document.Insert(cursorOffset, "/// ");
return;
}
if (IsInNonVerbatimString(lineAboveText, curLineText))
{
textArea.Document.Insert(cursorOffset, "\"");
textArea.Document.Insert(lineAbove.Offset + lineAbove.Length,
"\" +");
}
}
if (textArea.Options.AutoInsertBlockEnd && lineAbove != null && isInNormalCode)
{
string oldLineText = textArea.Document.GetText(lineAbove);
if (oldLineText.EndsWith("{", StringComparison.Ordinal))
{
if (NeedCurlyBracket(textArea.Document.Text))
{
int insertionPoint = curLine.Offset + curLine.Length;
textArea.Document.Insert(insertionPoint, terminator + "}");
IndentLine(textArea, textArea.Document.GetLineByNumber(lineNr + 1));
textArea.Caret.Offset = insertionPoint;
}
}
}
return;
}
}
public BamlDecompilerTypeSystem(PEFile mainModule, IAssemblyResolver assemblyResolver)
{
if (mainModule == null)
{
throw new ArgumentNullException(nameof(mainModule));
}
if (assemblyResolver == null)
{
throw new ArgumentNullException(nameof(assemblyResolver));
}
// Load referenced assemblies and type-forwarder references.
// This is necessary to make .NET Core/PCL binaries work better.
var referencedAssemblies = new List <PEFile>();
var assemblyReferenceQueue = new Queue <(bool IsAssembly, PEFile MainModule, object Reference)>();
var mainMetadata = mainModule.Metadata;
foreach (var h in mainMetadata.GetModuleReferences())
{
var moduleRef = mainMetadata.GetModuleReference(h);
var moduleName = mainMetadata.GetString(moduleRef.Name);
foreach (var fileHandle in mainMetadata.AssemblyFiles)
{
var file = mainMetadata.GetAssemblyFile(fileHandle);
if (mainMetadata.StringComparer.Equals(file.Name, moduleName) && file.ContainsMetadata)
{
assemblyReferenceQueue.Enqueue((false, mainModule, moduleName));
break;
}
}
}
foreach (var refs in mainModule.AssemblyReferences)
{
assemblyReferenceQueue.Enqueue((true, mainModule, refs));
}
foreach (var bamlReference in defaultBamlReferences)
{
assemblyReferenceQueue.Enqueue((true, mainModule, AssemblyNameReference.Parse(bamlReference)));
}
var comparer = KeyComparer.Create(((bool IsAssembly, PEFile MainModule, object Reference)reference) =>
reference.IsAssembly ? "A:" + ((IAssemblyReference)reference.Reference).FullName :
"M:" + reference.Reference);
var processedAssemblyReferences = new HashSet <(bool IsAssembly, PEFile Parent, object Reference)>(comparer);
while (assemblyReferenceQueue.Count > 0)
{
var asmRef = assemblyReferenceQueue.Dequeue();
if (!processedAssemblyReferences.Add(asmRef))
{
continue;
}
PEFile asm;
if (asmRef.IsAssembly)
{
asm = assemblyResolver.Resolve((IAssemblyReference)asmRef.Reference);
}
else
{
asm = assemblyResolver.ResolveModule(asmRef.MainModule, (string)asmRef.Reference);
}
if (asm != null)
{
referencedAssemblies.Add(asm);
var metadata = asm.Metadata;
foreach (var h in metadata.ExportedTypes)
{
var exportedType = metadata.GetExportedType(h);
switch (exportedType.Implementation.Kind)
{
case SRM.HandleKind.AssemblyReference:
assemblyReferenceQueue.Enqueue((true, asm, new AssemblyReference(asm, (SRM.AssemblyReferenceHandle)exportedType.Implementation)));
break;
case SRM.HandleKind.AssemblyFile:
var file = metadata.GetAssemblyFile((SRM.AssemblyFileHandle)exportedType.Implementation);
assemblyReferenceQueue.Enqueue((false, asm, metadata.GetString(file.Name)));
break;
}
}
}
}
var mainModuleWithOptions = mainModule.WithOptions(TypeSystemOptions.Default);
var referencedAssembliesWithOptions = referencedAssemblies.Select(file => file.WithOptions(TypeSystemOptions.Default));
// Primitive types are necessary to avoid assertions in ILReader.
// Fallback to MinimalCorlib to provide the primitive types.
if (!HasType(KnownTypeCode.Void) || !HasType(KnownTypeCode.Int32))
{
Init(mainModule.WithOptions(TypeSystemOptions.Default), referencedAssembliesWithOptions.Concat(new[] { MinimalCorlib.Instance }));
}
else
{
Init(mainModuleWithOptions, referencedAssembliesWithOptions);
}
this.MainModule = (MetadataModule)base.MainModule;
bool HasType(KnownTypeCode code)
{
TopLevelTypeName name = KnownTypeReference.Get(code).TypeName;
if (mainModule.GetTypeDefinition(name) != null)
{
return(true);
}
foreach (var file in referencedAssemblies)
{
if (file.GetTypeDefinition(name) != null)
{
return(true);
}
}
return(false);
}
}
internal MetadataTypeDefinition(MetadataModule module, TypeDefinitionHandle handle)
{
Debug.Assert(module != null);
Debug.Assert(!handle.IsNil);
this.module = module;
this.handle = handle;
var metadata = module.metadata;
var td = metadata.GetTypeDefinition(handle);
this.attributes = td.Attributes;
this.fullTypeName = td.GetFullTypeName(metadata);
// Find DeclaringType + KnownTypeCode:
if (fullTypeName.IsNested)
{
this.DeclaringTypeDefinition = module.GetDefinition(td.GetDeclaringType());
// Create type parameters:
this.TypeParameters = MetadataTypeParameter.Create(module, this.DeclaringTypeDefinition, this, td.GetGenericParameters());
}
else
{
// Create type parameters:
this.TypeParameters = MetadataTypeParameter.Create(module, this, td.GetGenericParameters());
var topLevelTypeName = fullTypeName.TopLevelTypeName;
for (int i = 0; i < KnownTypeReference.KnownTypeCodeCount; i++)
{
var ktr = KnownTypeReference.Get((KnownTypeCode)i);
if (ktr != null && ktr.TypeName == topLevelTypeName)
{
this.KnownTypeCode = (KnownTypeCode)i;
break;
}
}
}
// Find type kind:
if ((attributes & TypeAttributes.ClassSemanticsMask) == TypeAttributes.Interface)
{
this.Kind = TypeKind.Interface;
}
else if (td.IsEnum(metadata, out var underlyingType))
{
this.Kind = TypeKind.Enum;
this.EnumUnderlyingType = module.Compilation.FindType(underlyingType.ToKnownTypeCode());
}
else if (td.IsValueType(metadata))
{
if (KnownTypeCode == KnownTypeCode.Void)
{
this.Kind = TypeKind.Void;
}
else
{
this.Kind = TypeKind.Struct;
this.IsByRefLike = td.GetCustomAttributes().HasKnownAttribute(metadata, KnownAttribute.IsByRefLike);
this.IsReadOnly = td.GetCustomAttributes().HasKnownAttribute(metadata, KnownAttribute.IsReadOnly);
}
}
else if (td.IsDelegate(metadata))
{
this.Kind = TypeKind.Delegate;
}
else
{
this.Kind = TypeKind.Class;
this.HasExtensionMethods = this.IsStatic &&
(module.TypeSystemOptions & TypeSystemOptions.ExtensionMethods) == TypeSystemOptions.ExtensionMethods &&
td.GetCustomAttributes().HasKnownAttribute(metadata, KnownAttribute.Extension);
}
}
public AstType ConvertTypeReference(ITypeReference typeRef)
{
ArrayTypeReference array = typeRef as ArrayTypeReference;
if (array != null)
{
return(ConvertTypeReference(array.ElementType).MakeArrayType(array.Dimensions));
}
PointerTypeReference pointer = typeRef as PointerTypeReference;
if (pointer != null)
{
return(ConvertTypeReference(pointer.ElementType).MakePointerType());
}
ByReferenceType brt = typeRef as ByReferenceType;
if (brt != null)
{
return(ConvertTypeReference(brt.ElementType));
}
IType type = typeRef.Resolve(context);
if (type.Kind != TypeKind.Unknown)
{
return(ConvertType(type));
}
// Unknown type, let's try if we can find an appropriate type
// (anything is better than displaying a question mark)
KnownTypeReference knownType = typeRef as KnownTypeReference;
if (knownType != null)
{
string keyword = ReflectionHelper.GetCSharpNameByTypeCode(knownType.TypeCode);
if (keyword != null)
{
return(new PrimitiveType(keyword));
}
}
SimpleTypeOrNamespaceReference str = typeRef as SimpleTypeOrNamespaceReference;
if (str != null)
{
return(new SimpleType(str.Identifier, str.TypeArguments.Select(ConvertTypeReference)));
}
MemberTypeOrNamespaceReference mtr = typeRef as MemberTypeOrNamespaceReference;
if (mtr != null)
{
return(new MemberType(ConvertTypeReference(mtr.Target), mtr.Identifier, mtr.TypeArguments.Select(ConvertTypeReference))
{
IsDoubleColon = mtr.Target is AliasNamespaceReference
});
}
AliasNamespaceReference alias = typeRef as AliasNamespaceReference;
if (alias != null)
{
return(new SimpleType(alias.Identifier));
}
// Unknown type reference that couldn't be resolved
return(new SimpleType("?"));
}
public CorlibTypeDefinition(MinimalCorlib corlib, KnownTypeCode typeCode)
{
this.corlib = corlib;
this.typeCode = typeCode;
this.typeKind = KnownTypeReference.Get(typeCode).typeKind;
}
static void AppendTypeName(StringBuilder b, ITypeReference type, ITypeResolveContext context)
{
IType resolvedType = type as IType;
if (resolvedType != null)
{
AppendTypeName(b, resolvedType);
return;
}
KnownTypeReference knownType = type as KnownTypeReference;
if (knownType != null)
{
if (!string.IsNullOrEmpty(knownType.Namespace))
{
b.Append(knownType.Namespace);
b.Append('.');
}
b.Append(knownType.Name);
return;
}
GetClassTypeReference gctr = type as GetClassTypeReference;
if (gctr != null)
{
if (!string.IsNullOrEmpty(gctr.Namespace))
{
b.Append(gctr.Namespace);
b.Append('.');
}
b.Append(gctr.Name);
if (gctr.TypeParameterCount > 0)
{
b.Append('`');
b.Append(gctr.TypeParameterCount);
}
return;
}
NestedTypeReference ntr = type as NestedTypeReference;
if (ntr != null)
{
AppendTypeName(b, ntr.DeclaringTypeReference, context);
b.Append('.');
b.Append(ntr.Name);
if (ntr.AdditionalTypeParameterCount > 0)
{
b.Append('`');
b.Append(ntr.AdditionalTypeParameterCount);
}
return;
}
ParameterizedTypeReference pt = type as ParameterizedTypeReference;
if (pt != null && IsGetClassTypeReference(pt.GenericType))
{
AppendParameterizedTypeName(b, pt.GenericType, pt.TypeArguments, context);
return;
}
ArrayTypeReference array = type as ArrayTypeReference;
if (array != null)
{
AppendTypeName(b, array.ElementType, context);
b.Append('[');
if (array.Dimensions > 1)
{
for (int i = 0; i < array.Dimensions; i++)
{
if (i > 0)
{
b.Append(',');
}
b.Append("0:");
}
}
b.Append(']');
return;
}
PointerTypeReference ptr = type as PointerTypeReference;
if (ptr != null)
{
AppendTypeName(b, ptr.ElementType, context);
b.Append('*');
return;
}
ByReferenceTypeReference brtr = type as ByReferenceTypeReference;
if (brtr != null)
{
AppendTypeName(b, brtr.ElementType, context);
b.Append('@');
return;
}
if (context == null)
{
b.Append('?');
}
else
{
AppendTypeName(b, type.Resolve(context));
}
}
