private DefType ResolveTypeReference(TypeReferenceHandle handle)
{
TypeReference typeReference = _metadataReader.GetTypeReference(handle);
if (typeReference.ParentNamespaceOrType.HandleType == HandleType.TypeReference)
{
// Nested type case
MetadataType containingType = (MetadataType)ResolveTypeReference(typeReference.ParentNamespaceOrType.ToTypeReferenceHandle(_metadataReader));
return(containingType.GetNestedType(_metadataReader.GetString(typeReference.TypeName)));
}
else
{
// Cross-assembly reference
// Get remote module, and then lookup by namespace/name
ScopeReferenceHandle scopeReferenceHandle = default(ScopeReferenceHandle);
NamespaceReferenceHandle initialNamespaceReferenceHandle = typeReference.ParentNamespaceOrType.ToNamespaceReferenceHandle(_metadataReader);
NamespaceReferenceHandle namespaceReferenceHandle = initialNamespaceReferenceHandle;
do
{
NamespaceReference namespaceReference = _metadataReader.GetNamespaceReference(namespaceReferenceHandle);
if (namespaceReference.ParentScopeOrNamespace.HandleType == HandleType.ScopeReference)
{
scopeReferenceHandle = namespaceReference.ParentScopeOrNamespace.ToScopeReferenceHandle(_metadataReader);
}
else
{
namespaceReferenceHandle = namespaceReference.ParentScopeOrNamespace.ToNamespaceReferenceHandle(_metadataReader);
}
} while (scopeReferenceHandle.IsNull(_metadataReader));
ModuleDesc remoteModule = GetModule(scopeReferenceHandle);
string namespaceName = _metadataReader.GetNamespaceName(initialNamespaceReferenceHandle);
string typeName = _metadataReader.GetString(typeReference.TypeName);
MetadataType resolvedType = remoteModule.GetType(namespaceName, typeName, throwIfNotFound: false);
if (resolvedType != null)
{
return(resolvedType);
}
// Special handling for the magic __Canon types cannot be currently put into
// NativeFormatModule because GetType returns a MetadataType.
if (remoteModule == _context.SystemModule)
{
string qualifiedTypeName = namespaceName + "." + typeName;
if (qualifiedTypeName == CanonType.FullName)
{
return(_context.CanonType);
}
if (qualifiedTypeName == UniversalCanonType.FullName)
{
return(_context.UniversalCanonType);
}
}
throw new NotImplementedException();
}
}
public static bool CompareNamespaceReferenceAcrossModules(NamespaceReferenceHandle nr1, MetadataReader mr1, NamespaceReferenceHandle nr2, MetadataReader mr2)
{
NamespaceReference nrData1 = mr1.GetNamespaceReference(nr1);
NamespaceReference nrData2 = mr2.GetNamespaceReference(nr2);
if (nrData1.Name.IsNull(mr1) != nrData2.Name.IsNull(mr2))
{
return(false);
}
if (!nrData1.Name.IsNull(mr1))
{
if (!nrData1.Name.StringEquals(nrData2.Name.GetConstantStringValue(mr2).Value, mr1))
{
return(false);
}
}
if (nrData1.ParentScopeOrNamespace.HandleType != nrData1.ParentScopeOrNamespace.HandleType)
{
return(false);
}
if (nrData1.ParentScopeOrNamespace.HandleType == HandleType.NamespaceReference)
{
return(CompareNamespaceReferenceAcrossModules(nrData1.ParentScopeOrNamespace.ToNamespaceReferenceHandle(mr1), mr1, nrData2.ParentScopeOrNamespace.ToNamespaceReferenceHandle(mr2), mr2));
}
return(CompareScopeReferenceAcrossModules(nrData1.ParentScopeOrNamespace.ToScopeReferenceHandle(mr1), mr1, nrData2.ParentScopeOrNamespace.ToScopeReferenceHandle(mr2), mr2));
}
object Create(IToolTipProviderContext context, NamespaceReference nsRef)
{
var provider = context.Create();
provider.SetImage(nsRef);
context.Language.WriteNamespaceToolTip(provider.Output, nsRef.Namespace);
return(provider.Create());
}
object Create(IDocumentViewerToolTipProviderContext context, NamespaceReference nsRef)
{
var provider = context.Create();
provider.SetImage(nsRef);
context.Decompiler.WriteNamespaceToolTip(provider.Output, nsRef.Namespace);
return(provider.Create());
}
internal ContainerBinder(Binder containingScope, NamespaceReference mergedContainer, IEnumerable <ImportedSymbol> imports)
: base(containingScope)
{
this.mergedContainer = mergedContainer;
foreach (var import in imports)
{
this.imports.Add(import.AliasName, import);
}
}
public static NamespaceReference CreateNamespaceReference(XPathNavigator namespaceElement)
{
if (namespaceElement == null)
{
throw new ArgumentNullException("namespaceElement");
}
string api = (string)namespaceElement.Evaluate(referenceApiExpression);
NamespaceReference reference = new NamespaceReference(api);
return(reference);
}
/// <summary>
/// Emit namespace reference.
/// </summary>
/// <param name="namespaceRefHandle">Namespace reference handle</param>
private void EmitNamespaceReferenceName(NamespaceReferenceHandle namespaceRefHandle)
{
NamespaceReference namespaceRef = _metadataReader.GetNamespaceReference(namespaceRefHandle);
if (!namespaceRef.ParentScopeOrNamespace.IsNull(_metadataReader) &&
namespaceRef.ParentScopeOrNamespace.HandleType == HandleType.NamespaceReference)
{
EmitNamespaceReferenceName(namespaceRef.ParentScopeOrNamespace.ToNamespaceReferenceHandle(_metadataReader));
_outputBuilder.Append('.');
}
EmitString(namespaceRef.Name);
}
private NamespaceReference HandleNamespaceReference(Cts.ModuleDesc parentScope, string namespaceString)
{
NamespaceReference result;
NamespaceKey key = new NamespaceKey(parentScope, namespaceString);
if (_namespaceRefs.TryGetValue(key, out result))
{
return(result);
}
ScopeReference scope = HandleScopeReference(parentScope);
NamespaceReference rootNamespace;
key = new NamespaceKey(parentScope, null);
if (!_namespaceRefs.TryGetValue(key, out rootNamespace))
{
rootNamespace = new NamespaceReference
{
Name = null,
ParentScopeOrNamespace = scope,
};
_namespaceRefs.Add(key, rootNamespace);
}
NamespaceReference currentNamespace = rootNamespace;
string currentNamespaceName = String.Empty;
foreach (var segment in namespaceString.Split('.'))
{
string nextNamespaceName = currentNamespaceName;
if (nextNamespaceName.Length > 0)
{
nextNamespaceName = nextNamespaceName + '.';
}
nextNamespaceName += segment;
NamespaceReference nextNamespace;
key = new NamespaceKey(parentScope, nextNamespaceName);
if (!_namespaceRefs.TryGetValue(key, out nextNamespace))
{
nextNamespace = new NamespaceReference
{
Name = HandleString(segment.Length == 0 ? null : segment),
ParentScopeOrNamespace = currentNamespace
};
_namespaceRefs.Add(key, nextNamespace);
}
currentNamespace = nextNamespace;
currentNamespaceName = nextNamespaceName;
}
return(currentNamespace);
}
public void WriteReference(Reference reference, ReferenceLinkDisplayOptions options, XmlWriter writer)
{
if (reference == null)
{
throw new ArgumentNullException("reference");
}
if (writer == null)
{
throw new ArgumentNullException("writer");
}
NamespaceReference space = reference as NamespaceReference;
if (space != null)
{
WriteNamespace(space, options, writer);
return;
}
TypeReference type = reference as TypeReference;
if (type != null)
{
WriteType(type, options, writer);
return;
}
MemberReference member = reference as MemberReference;
if (member != null)
{
WriteMember(member, options, writer);
return;
}
ExtensionMethodReference extMethod = reference as ExtensionMethodReference;
if (extMethod != null)
{
WriteExtensionMethod(extMethod, options, writer);
return;
}
InvalidReference invalid = reference as InvalidReference;
if (invalid != null)
{
WriteInvalid(invalid, options, writer);
return;
}
throw new InvalidOperationException();
}
private void AddReferenceToNewNamespace(ElementReferenceExpression namespaceReferenceExpression, TextDocument Doc)
{
var NamespaceReference = new NamespaceReference(namespaceReferenceExpression.FullSignature);
var Code = CodeRush.CodeMod.GenerateCode(NamespaceReference, false);
var LastNamespaceReference = CodeRush.Refactoring.FindAllNamespaceReferences(Doc.FileNode).LastOrDefault();
if (LastNamespaceReference != null)
{
Doc.QueueInsert(LastNamespaceReference.Range.Start.OffsetPoint(1, 0), Code);
}
else
{
var FirstNamespace = Doc.FileNode.FindChildByElementType(LanguageElementType.Namespace);
Doc.QueueInsert(FirstNamespace.Range.Start, Code);
}
}
public ScopeReference GetScopeReferenceOfType(TypeReference typeReference)
{
Assert.NotNull(typeReference);
ScopeReference scope = null;
NamespaceReference currentNamespaceReference = typeReference.ParentNamespaceOrType as NamespaceReference;
while (scope == null)
{
Assert.NotNull(currentNamespaceReference);
scope = currentNamespaceReference.ParentScopeOrNamespace as ScopeReference;
currentNamespaceReference = currentNamespaceReference.ParentScopeOrNamespace as NamespaceReference;
}
return(scope);
}
/// <summary>
/// Emit namespace reference.
/// </summary>
/// <param name="namespaceRefHandle">Namespace reference handle</param>
private void EmitNamespaceReferenceName(NamespaceReferenceHandle namespaceRefHandle)
{
NamespaceReference namespaceRef = _metadataReader.GetNamespaceReference(namespaceRefHandle);
if (!namespaceRef.ParentScopeOrNamespace.IsNull(_metadataReader) &&
namespaceRef.ParentScopeOrNamespace.HandleType == HandleType.NamespaceReference)
{
int charsWritten = _outputBuilder.Length;
EmitNamespaceReferenceName(namespaceRef.ParentScopeOrNamespace.ToNamespaceReferenceHandle(_metadataReader));
if (_outputBuilder.Length - charsWritten > 0)
{
_outputBuilder.Append('.');
}
}
EmitString(namespaceRef.Name);
}
FileTabReferenceResult Create(NamespaceReference nsRef)
{
var asm = fileTreeView.FileManager.Resolve(nsRef.Assembly, null) as IDnSpyDotNetFile;
if (asm == null)
{
return(null);
}
var mod = asm.Children.FirstOrDefault() as IDnSpyDotNetFile;
if (mod == null)
{
return(null);
}
var node = fileTreeView.FindNamespaceNode(mod, nsRef.Namespace);
return(node == null ? null : Create(node));
}
DocumentTabReferenceResult Create(NamespaceReference nsRef)
{
var asm = documentTreeView.DocumentService.Resolve(nsRef.Assembly, null) as IDsDotNetDocument;
if (asm == null)
{
return(null);
}
var mod = asm.Children.FirstOrDefault() as IDsDotNetDocument;
if (mod == null)
{
return(null);
}
var node = documentTreeView.FindNamespaceNode(mod, nsRef.Namespace);
return(node == null ? null : Create(node));
}
private String GetTypeFullNameFromTypeRef(TypeReferenceHandle typeReferenceHandle, MetadataReader reader)
{
String s = "";
TypeReference typeReference = typeReferenceHandle.GetTypeReference(reader);
s = typeReference.TypeName.GetString(reader);
Handle parentHandle = typeReference.ParentNamespaceOrType;
HandleType parentHandleType = parentHandle.HandleType;
if (parentHandleType == HandleType.TypeReference)
{
String containingTypeName = GetTypeFullNameFromTypeRef(parentHandle.ToTypeReferenceHandle(reader), reader);
s = containingTypeName + "+" + s;
}
else if (parentHandleType == HandleType.NamespaceReference)
{
NamespaceReferenceHandle namespaceReferenceHandle = parentHandle.ToNamespaceReferenceHandle(reader);
for (;;)
{
NamespaceReference namespaceReference = namespaceReferenceHandle.GetNamespaceReference(reader);
String namespacePart = namespaceReference.Name.GetStringOrNull(reader);
if (namespacePart == null)
{
break; // Reached the root namespace.
}
s = namespacePart + "." + s;
if (namespaceReference.ParentScopeOrNamespace.HandleType != HandleType.NamespaceReference)
{
break; // Should have reached the root namespace first but this helper is for ToString() - better to
}
// return partial information than crash.
namespaceReferenceHandle = namespaceReference.ParentScopeOrNamespace.ToNamespaceReferenceHandle(reader);
}
}
else
{
// If we got here, the metadata is illegal but this helper is for ToString() - better to
// return something partial than throw.
}
return(s);
}
private static void AppendNamespaceHashCode(ref HashCodeBuilder builder, NamespaceReferenceHandle namespaceRefHandle, MetadataReader reader)
{
NamespaceReference namespaceReference = reader.GetNamespaceReference(namespaceRefHandle);
Handle parentHandle = namespaceReference.ParentScopeOrNamespace;
HandleType parentHandleType = parentHandle.HandleType;
if (parentHandleType == HandleType.NamespaceReference)
{
AppendNamespaceHashCode(ref builder, parentHandle.ToNamespaceReferenceHandle(reader), reader);
string namespaceNamePart = reader.GetString(namespaceReference.Name);
builder.Append(namespaceNamePart);
builder.Append(".");
}
else
{
Debug.Assert(parentHandleType == HandleType.ScopeReference);
Debug.Assert(String.IsNullOrEmpty(reader.GetString(namespaceReference.Name)), "Root namespace with a name?");
}
}
public static bool CompareNamespaceReferenceToDefinition(NamespaceReferenceHandle nr1, MetadataReader mr1, NamespaceDefinitionHandle nd2, MetadataReader mr2)
{
NamespaceReference nrData1 = mr1.GetNamespaceReference(nr1);
NamespaceDefinition ndData2 = mr2.GetNamespaceDefinition(nd2);
if (nrData1.Name.IsNull(mr1) != ndData2.Name.IsNull(mr2))
{
return(false);
}
if (!nrData1.Name.IsNull(mr1))
{
if (!nrData1.Name.StringEquals(ndData2.Name.GetConstantStringValue(mr2).Value, mr1))
{
return(false);
}
}
switch (nrData1.ParentScopeOrNamespace.HandleType)
{
case HandleType.NamespaceReference:
if (ndData2.ParentScopeOrNamespace.HandleType != HandleType.NamespaceDefinition)
{
return(false);
}
return(CompareNamespaceReferenceToDefinition(nrData1.ParentScopeOrNamespace.ToNamespaceReferenceHandle(mr1), mr1, ndData2.ParentScopeOrNamespace.ToNamespaceDefinitionHandle(mr2), mr2));
case HandleType.ScopeReference:
if (ndData2.ParentScopeOrNamespace.HandleType != HandleType.ScopeDefinition)
{
return(false);
}
return(CompareScopeReferenceToDefinition(nrData1.ParentScopeOrNamespace.ToScopeReferenceHandle(mr1), mr1, ndData2.ParentScopeOrNamespace.ToScopeDefinitionHandle(mr2), mr2));
default:
Debug.Assert(false);
throw new BadImageFormatException();
}
}
internal static string GetNamespaceName(this MetadataReader metadataReader, NamespaceReferenceHandle namespaceReferenceHandle)
{
if (namespaceReferenceHandle.IsNull(metadataReader))
{
return(null);
}
else
{
// TODO! Cache this result, or do something to make it more efficient.
NamespaceReference namespaceReference = namespaceReferenceHandle.GetNamespaceReference(metadataReader);
string name = metadataReader.GetString(namespaceReference.Name) ?? "";
if (namespaceReference.ParentScopeOrNamespace.HandleType == HandleType.NamespaceReference)
{
string parentName = metadataReader.GetNamespaceName(namespaceReference.ParentScopeOrNamespace.ToNamespaceReferenceHandle(metadataReader));
if (!string.IsNullOrEmpty(parentName))
{
name = parentName + "." + name;
}
}
return(name);
}
}
private static string GetTypeFullNameFromTypeRef(TypeReferenceHandle typeReferenceHandle, MetadataReader reader, List <int> genericParameterOffsets)
{
TypeReference typeReference = typeReferenceHandle.GetTypeReference(reader);
string s = typeReference.TypeName.GetString(reader);
Handle parentHandle = typeReference.ParentNamespaceOrType;
HandleType parentHandleType = parentHandle.HandleType;
if (parentHandleType == HandleType.TypeReference)
{
string containingTypeName = GetTypeFullNameFromTypeRef(parentHandle.ToTypeReferenceHandle(reader), reader, genericParameterOffsets);
s = containingTypeName + "." + s;
}
else if (parentHandleType == HandleType.NamespaceReference)
{
NamespaceReferenceHandle namespaceReferenceHandle = parentHandle.ToNamespaceReferenceHandle(reader);
for (;;)
{
NamespaceReference namespaceReference = namespaceReferenceHandle.GetNamespaceReference(reader);
string namespacePart = namespaceReference.Name.GetStringOrNull(reader);
if (namespacePart == null)
{
break; // Reached the root namespace.
}
s = namespacePart + "." + s;
if (namespaceReference.ParentScopeOrNamespace.HandleType != HandleType.NamespaceReference)
{
break; // Should have reached the root namespace first but this helper is for ToString() - better to
}
// return partial information than crash.
namespaceReferenceHandle = namespaceReference.ParentScopeOrNamespace.ToNamespaceReferenceHandle(reader);
}
}
else
{
// If we got here, the metadata is illegal but this helper is for ToString() - better to
// return something partial than throw.
}
return(ConvertBackTickNameToNameWithReducerInputFormat(s, genericParameterOffsets));
}
public void WriteNamespace(NamespaceReference spaceReference, ReferenceLinkDisplayOptions options,
XmlWriter writer)
{
if (spaceReference == null)
{
throw new ArgumentNullException("spaceReference");
}
if (writer == null)
{
throw new ArgumentNullException("writer");
}
NamespaceTarget spaceTarget = spaceReference.Resolve(_targets) as NamespaceTarget;
if (spaceTarget != null)
{
WriteNamespaceTarget(spaceTarget, options, writer);
}
else
{
ReferenceTextUtilities.WriteNamespaceReference(spaceReference, options, writer);
}
}
public static bool IsPartOfTheActiveSolution(this NamespaceReference nref)
{
var c = (nref.Solution as ISolutionElement).Projects.Cast <ProjectElement>().Where(p => nref.Name.StartsWith(p.Name)).Count();
return(c > 0);
}
/// <summary> /// Appends the specified namespace reference. /// </summary> /// <param name="namespaceReference">The namespace reference.</param> protected abstract void AppendNamespaceReference(NamespaceReference namespaceReference);
protected override void OnReadXml(XmlReader reader)
{
base.OnReadXml(reader);
// This reads only the target node...
if (!String.Equals(reader.Name, "TypeTarget",
StringComparison.OrdinalIgnoreCase))
{
return;
}
name = reader.GetAttribute("name");
templates = new List <string>();
XmlNodeType nodeType = XmlNodeType.None;
while (reader.Read())
{
nodeType = reader.NodeType;
if (nodeType == XmlNodeType.Element)
{
// Read the base contents in...
if (String.Equals(reader.Name, "Target",
StringComparison.OrdinalIgnoreCase))
{
base.OnReadXml(reader);
}
else if (String.Equals(reader.Name, "NamespaceReference",
StringComparison.OrdinalIgnoreCase))
{
containingNamespace = new NamespaceReference();
containingNamespace.ReadXml(reader);
}
else if (String.Equals(reader.Name, "SimpleTypeReference",
StringComparison.OrdinalIgnoreCase))
{
containingType = new SimpleTypeReference();
containingType.ReadXml(reader);
}
else if (String.Equals(reader.Name, "Templates",
StringComparison.OrdinalIgnoreCase))
{
while (reader.Read())
{
nodeType = reader.NodeType;
if (nodeType == XmlNodeType.Element)
{
if (String.Equals(reader.Name, "Template",
StringComparison.OrdinalIgnoreCase))
{
templates.Add(reader.GetAttribute("value"));
}
}
else if (nodeType == XmlNodeType.EndElement)
{
if (String.Equals(reader.Name, "Templates",
StringComparison.OrdinalIgnoreCase))
{
break;
}
}
}
}
}
else if (nodeType == XmlNodeType.EndElement)
{
if (String.Equals(reader.Name, "TypeTarget",
StringComparison.OrdinalIgnoreCase))
{
break;
}
}
}
}
/// <summary>
/// Appends the specified namespace reference.
/// </summary>
/// <param name="namespaceReference">The namespace reference.</param>
protected override void AppendNamespaceReference(NamespaceReference namespaceReference)
{
throw new NotImplementedException();
}
// Caller should lock peFileToObjectModel
internal CoreTypes(PEFileToObjectModel peFileToObjectModel)
{
INameTable nameTable = peFileToObjectModel.NameTable;
PEFileReader peFileReader = peFileToObjectModel.PEFileReader;
PeReader peReader = peFileToObjectModel.ModuleReader;
Module module = peFileToObjectModel.Module;
AssemblyIdentity /*?*/ assemblyIdentity = module.ModuleIdentity as AssemblyIdentity;
int systemName = nameTable.System.UniqueKey;
int voidName = nameTable.Void.UniqueKey;
int booleanName = nameTable.Boolean.UniqueKey;
int charName = nameTable.Char.UniqueKey;
int byteName = nameTable.Byte.UniqueKey;
int sByteName = nameTable.SByte.UniqueKey;
int int16Name = nameTable.Int16.UniqueKey;
int uint16Name = nameTable.UInt16.UniqueKey;
int int32Name = nameTable.Int32.UniqueKey;
int uint32Name = nameTable.UInt32.UniqueKey;
int int64Name = nameTable.Int64.UniqueKey;
int uint64Name = nameTable.UInt64.UniqueKey;
int stringName = nameTable.String.UniqueKey;
int intPtrName = nameTable.IntPtr.UniqueKey;
int uintPtrName = nameTable.UIntPtr.UniqueKey;
int objectName = nameTable.Object.UniqueKey;
int singleName = nameTable.Single.UniqueKey;
int doubleName = nameTable.Double.UniqueKey;
int decimalName = nameTable.Decimal.UniqueKey;
int typedReference = nameTable.TypedReference.UniqueKey;
int enumName = nameTable.Enum.UniqueKey;
int valueTypeName = nameTable.ValueType.UniqueKey;
int multicastDelegateName = nameTable.MulticastDelegate.UniqueKey;
int typeName = nameTable.Type.UniqueKey;
int arrayName = nameTable.Array.UniqueKey;
int paramArrayAttributeName = peReader.ParamArrayAttribute.UniqueKey;
if (assemblyIdentity != null && assemblyIdentity.Equals(peReader.metadataReaderHost.CoreAssemblySymbolicIdentity))
{
peReader.RegisterCoreAssembly(module as Assembly);
uint numberOfTypeDefs = peFileReader.TypeDefTable.NumberOfRows;
for (uint i = 1; i <= numberOfTypeDefs; ++i)
{
TypeDefRow typeDefRow = peFileReader.TypeDefTable[i];
if (!typeDefRow.IsNested)
{
int namespaceName = peFileToObjectModel.GetNameFromOffset(typeDefRow.Namespace).UniqueKey;
if (namespaceName == systemName)
{
int typeDefName = peFileToObjectModel.GetNameFromOffset(typeDefRow.Name).UniqueKey;
if (typeDefName == voidName)
{
this.SystemVoid = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.Void);
}
else if (typeDefName == booleanName)
{
this.SystemBoolean = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.Boolean);
}
else if (typeDefName == charName)
{
this.SystemChar = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.Char);
}
else if (typeDefName == byteName)
{
this.SystemByte = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.Byte);
}
else if (typeDefName == sByteName)
{
this.SystemSByte = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.SByte);
}
else if (typeDefName == int16Name)
{
this.SystemInt16 = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.Int16);
}
else if (typeDefName == uint16Name)
{
this.SystemUInt16 = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.UInt16);
}
else if (typeDefName == int32Name)
{
this.SystemInt32 = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.Int32);
}
else if (typeDefName == uint32Name)
{
this.SystemUInt32 = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.UInt32);
}
else if (typeDefName == int64Name)
{
this.SystemInt64 = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.Int64);
}
else if (typeDefName == uint64Name)
{
this.SystemUInt64 = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.UInt64);
}
else if (typeDefName == stringName)
{
this.SystemString = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.String);
}
else if (typeDefName == intPtrName)
{
this.SystemIntPtr = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.IntPtr);
}
else if (typeDefName == uintPtrName)
{
this.SystemUIntPtr = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.UIntPtr);
}
else if (typeDefName == objectName)
{
this.SystemObject = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.Object);
}
else if (typeDefName == singleName)
{
this.SystemSingle = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.Single);
}
else if (typeDefName == doubleName)
{
this.SystemDouble = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.Double);
}
else if (typeDefName == decimalName)
{
this.SystemDecimal = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == typedReference)
{
this.SystemTypedReference = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.TypedReference);
}
else if (typeDefName == enumName)
{
this.SystemEnum = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == valueTypeName)
{
this.SystemValueType = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == multicastDelegateName)
{
this.SystemMulticastDelegate = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == typeName)
{
this.SystemType = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == arrayName)
{
this.SystemArray = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == paramArrayAttributeName)
{
this.SystemParamArrayAttribute = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive);
}
}
}
}
}
else
{
uint numberOfTypeRefs = peFileReader.TypeRefTable.NumberOfRows;
AssemblyReference /*?*/ coreAssemblyRef = peFileToObjectModel.FindAssemblyReference(peReader.metadataReaderHost.CoreAssemblySymbolicIdentity);
if (coreAssemblyRef == null)
{
// Error...
coreAssemblyRef = new AssemblyReference(peFileToObjectModel, 0, peReader.metadataReaderHost.CoreAssemblySymbolicIdentity, AssemblyFlags.Retargetable);
}
uint coreAssemblyRefToken = coreAssemblyRef.TokenValue;
for (uint i = 1; i <= numberOfTypeRefs; ++i)
{
TypeRefRow typeRefRow = peFileReader.TypeRefTable[i];
if (typeRefRow.ResolutionScope != coreAssemblyRefToken)
{
continue;
}
int namespaceName = peFileToObjectModel.GetNameFromOffset(typeRefRow.Namespace).UniqueKey;
if (namespaceName == systemName)
{
int typeDefName = peFileToObjectModel.GetNameFromOffset(typeRefRow.Name).UniqueKey;
if (typeDefName == voidName)
{
this.SystemVoid = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.Void);
}
else if (typeDefName == booleanName)
{
this.SystemBoolean = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.Boolean);
}
else if (typeDefName == charName)
{
this.SystemChar = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.Char);
}
else if (typeDefName == byteName)
{
this.SystemByte = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.Byte);
}
else if (typeDefName == sByteName)
{
this.SystemSByte = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.SByte);
}
else if (typeDefName == int16Name)
{
this.SystemInt16 = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.Int16);
}
else if (typeDefName == uint16Name)
{
this.SystemUInt16 = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.UInt16);
}
else if (typeDefName == int32Name)
{
this.SystemInt32 = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.Int32);
}
else if (typeDefName == uint32Name)
{
this.SystemUInt32 = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.UInt32);
}
else if (typeDefName == int64Name)
{
this.SystemInt64 = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.Int64);
}
else if (typeDefName == uint64Name)
{
this.SystemUInt64 = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.UInt64);
}
else if (typeDefName == stringName)
{
this.SystemString = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.String);
}
else if (typeDefName == intPtrName)
{
this.SystemIntPtr = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.IntPtr);
}
else if (typeDefName == uintPtrName)
{
this.SystemUIntPtr = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.UIntPtr);
}
else if (typeDefName == objectName)
{
this.SystemObject = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.Object);
}
else if (typeDefName == singleName)
{
this.SystemSingle = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.Single);
}
else if (typeDefName == doubleName)
{
this.SystemDouble = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.Double);
}
else if (typeDefName == decimalName)
{
this.SystemDecimal = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == typedReference)
{
this.SystemTypedReference = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.TypedReference);
}
else if (typeDefName == enumName)
{
this.SystemEnum = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == valueTypeName)
{
this.SystemValueType = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == multicastDelegateName)
{
this.SystemMulticastDelegate = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == typeName)
{
this.SystemType = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == arrayName)
{
this.SystemArray = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == paramArrayAttributeName)
{
this.SystemParamArrayAttribute = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, ModuleSignatureTypeCode.NotModulePrimitive);
}
}
}
NamespaceReference systemNSR = peFileToObjectModel.GetNamespaceReferenceForString(coreAssemblyRef, nameTable.System);
if (this.SystemVoid == null)
{
this.SystemVoid = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Void, ModuleSignatureTypeCode.Void);
}
if (this.SystemBoolean == null)
{
this.SystemBoolean = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Boolean, ModuleSignatureTypeCode.Boolean);
}
if (this.SystemChar == null)
{
this.SystemChar = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Char, ModuleSignatureTypeCode.Char);
}
if (this.SystemByte == null)
{
this.SystemByte = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Byte, ModuleSignatureTypeCode.Byte);
}
if (this.SystemSByte == null)
{
this.SystemSByte = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.SByte, ModuleSignatureTypeCode.SByte);
}
if (this.SystemInt16 == null)
{
this.SystemInt16 = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Int16, ModuleSignatureTypeCode.Int16);
}
if (this.SystemUInt16 == null)
{
this.SystemUInt16 = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.UInt16, ModuleSignatureTypeCode.UInt16);
}
if (this.SystemInt32 == null)
{
this.SystemInt32 = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Int32, ModuleSignatureTypeCode.Int32);
}
if (this.SystemUInt32 == null)
{
this.SystemUInt32 = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.UInt32, ModuleSignatureTypeCode.UInt32);
}
if (this.SystemInt64 == null)
{
this.SystemInt64 = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Int64, ModuleSignatureTypeCode.Int64);
}
if (this.SystemUInt64 == null)
{
this.SystemUInt64 = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.UInt64, ModuleSignatureTypeCode.UInt64);
}
if (this.SystemString == null)
{
this.SystemString = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.String, ModuleSignatureTypeCode.String);
}
if (this.SystemIntPtr == null)
{
this.SystemIntPtr = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.IntPtr, ModuleSignatureTypeCode.IntPtr);
}
if (this.SystemUIntPtr == null)
{
this.SystemUIntPtr = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.UIntPtr, ModuleSignatureTypeCode.UIntPtr);
}
if (this.SystemObject == null)
{
this.SystemObject = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Object, ModuleSignatureTypeCode.Object);
}
if (this.SystemSingle == null)
{
this.SystemSingle = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Single, ModuleSignatureTypeCode.Single);
}
if (this.SystemDouble == null)
{
this.SystemDouble = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Double, ModuleSignatureTypeCode.Double);
}
if (this.SystemDecimal == null)
{
this.SystemDecimal = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Decimal, ModuleSignatureTypeCode.NotModulePrimitive);
}
if (this.SystemTypedReference == null)
{
this.SystemTypedReference = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.TypedReference, ModuleSignatureTypeCode.NotModulePrimitive);
}
if (this.SystemEnum == null)
{
this.SystemEnum = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Enum, ModuleSignatureTypeCode.NotModulePrimitive);
}
if (this.SystemValueType == null)
{
this.SystemValueType = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.ValueType, ModuleSignatureTypeCode.NotModulePrimitive);
}
if (this.SystemMulticastDelegate == null)
{
this.SystemMulticastDelegate = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.MulticastDelegate, ModuleSignatureTypeCode.NotModulePrimitive);
}
if (this.SystemType == null)
{
this.SystemType = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Type, ModuleSignatureTypeCode.NotModulePrimitive);
}
if (this.SystemArray == null)
{
this.SystemArray = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, nameTable.Array, ModuleSignatureTypeCode.NotModulePrimitive);
}
if (this.SystemParamArrayAttribute == null)
{
this.SystemParamArrayAttribute = peFileToObjectModel.typeCache.CreateCoreTypeReference(coreAssemblyRef, systemNSR, peReader.ParamArrayAttribute, ModuleSignatureTypeCode.NotModulePrimitive);
}
}
}
// Caller should lock peFileToObjectModel
internal CoreTypes(PEFileToObjectModel peFileToObjectModel)
{
INameTable nameTable = peFileToObjectModel.NameTable;
PEFileReader peFileReader = peFileToObjectModel.PEFileReader;
PeReader peReader = peFileToObjectModel.ModuleReader;
Module module = peFileToObjectModel.Module;
AssemblyIdentity /*?*/ assemblyIdentity = module.ModuleIdentity as AssemblyIdentity;
//This does more than just initialize the five types exposed above, since it is also
//necessary to initialize any typedefs and typerefs to types with short forms
//in such a way that they have the correct type codes.
int systemName = nameTable.System.UniqueKey;
int voidName = nameTable.Void.UniqueKey;
int booleanName = nameTable.Boolean.UniqueKey;
int charName = nameTable.Char.UniqueKey;
int byteName = nameTable.Byte.UniqueKey;
int sByteName = nameTable.SByte.UniqueKey;
int int16Name = nameTable.Int16.UniqueKey;
int uint16Name = nameTable.UInt16.UniqueKey;
int int32Name = nameTable.Int32.UniqueKey;
int uint32Name = nameTable.UInt32.UniqueKey;
int int64Name = nameTable.Int64.UniqueKey;
int uint64Name = nameTable.UInt64.UniqueKey;
int stringName = nameTable.String.UniqueKey;
int intPtrName = nameTable.IntPtr.UniqueKey;
int uintPtrName = nameTable.UIntPtr.UniqueKey;
int objectName = nameTable.Object.UniqueKey;
int singleName = nameTable.Single.UniqueKey;
int doubleName = nameTable.Double.UniqueKey;
int decimalName = nameTable.Decimal.UniqueKey;
int typedReference = nameTable.TypedReference.UniqueKey;
int enumName = nameTable.Enum.UniqueKey;
int valueTypeName = nameTable.ValueType.UniqueKey;
int multicastDelegateName = nameTable.MulticastDelegate.UniqueKey;
int typeName = nameTable.Type.UniqueKey;
int arrayName = nameTable.Array.UniqueKey;
int paramArrayAttributeName = peReader.ParamArrayAttribute.UniqueKey;
if (assemblyIdentity != null && assemblyIdentity.Equals(peReader.metadataReaderHost.CoreAssemblySymbolicIdentity))
{
peReader.RegisterCoreAssembly(module as Assembly);
uint numberOfTypeDefs = peFileReader.TypeDefTable.NumberOfRows;
for (uint i = 1; i <= numberOfTypeDefs; ++i)
{
TypeDefRow typeDefRow = peFileReader.TypeDefTable[i];
if (!typeDefRow.IsNested)
{
int namespaceName = peFileToObjectModel.GetNameFromOffset(typeDefRow.Namespace).UniqueKey;
if (namespaceName == systemName)
{
int typeDefName = peFileToObjectModel.GetNameFromOffset(typeDefRow.Name).UniqueKey;
if (typeDefName == voidName)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Void);
}
else if (typeDefName == booleanName)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Boolean);
}
else if (typeDefName == charName)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Char);
}
else if (typeDefName == byteName)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Byte);
}
else if (typeDefName == sByteName)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.SByte);
}
else if (typeDefName == int16Name)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Int16);
}
else if (typeDefName == uint16Name)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.UInt16);
}
else if (typeDefName == int32Name)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Int32);
}
else if (typeDefName == uint32Name)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.UInt32);
}
else if (typeDefName == int64Name)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Int64);
}
else if (typeDefName == uint64Name)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.UInt64);
}
else if (typeDefName == stringName)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.String);
}
else if (typeDefName == intPtrName)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.IntPtr);
}
else if (typeDefName == uintPtrName)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.UIntPtr);
}
else if (typeDefName == objectName)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Object);
}
else if (typeDefName == singleName)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Single);
}
else if (typeDefName == doubleName)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Double);
}
else if (typeDefName == typedReference)
{
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.TypedReference);
}
else if (typeDefName == enumName)
{
this.SystemEnum = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == valueTypeName)
{
this.SystemValueType = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == multicastDelegateName)
{
this.SystemMulticastDelegate = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == typeName)
{
this.SystemType = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == paramArrayAttributeName)
{
this.SystemParamArrayAttribute = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
}
}
}
}
else
{
uint numberOfTypeRefs = peFileReader.TypeRefTable.NumberOfRows;
AssemblyReference /*?*/ coreAssemblyRef = peFileToObjectModel.FindAssemblyReference(peFileToObjectModel.CoreAssemblySymbolicIdentity);
if (coreAssemblyRef == null)
{
// Error...
coreAssemblyRef = new AssemblyReference(peFileToObjectModel, 1, peFileToObjectModel.CoreAssemblySymbolicIdentity, AssemblyFlags.Retargetable);
}
uint coreAssemblyRefToken = coreAssemblyRef.TokenValue;
for (uint i = 1; i <= numberOfTypeRefs; ++i)
{
TypeRefRow typeRefRow = peFileReader.TypeRefTable[i];
if (typeRefRow.ResolutionScope != coreAssemblyRefToken)
{
continue;
}
int namespaceName = peFileToObjectModel.GetNameFromOffset(typeRefRow.Namespace).UniqueKey;
if (namespaceName == systemName)
{
int typeDefName = peFileToObjectModel.GetNameFromOffset(typeRefRow.Name).UniqueKey;
if (typeDefName == voidName)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Void);
}
else if (typeDefName == booleanName)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Boolean);
}
else if (typeDefName == charName)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Char);
}
else if (typeDefName == byteName)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Byte);
}
else if (typeDefName == sByteName)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.SByte);
}
else if (typeDefName == int16Name)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Int16);
}
else if (typeDefName == uint16Name)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.UInt16);
}
else if (typeDefName == int32Name)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Int32);
}
else if (typeDefName == uint32Name)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.UInt32);
}
else if (typeDefName == int64Name)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Int64);
}
else if (typeDefName == uint64Name)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.UInt64);
}
else if (typeDefName == stringName)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.String);
}
else if (typeDefName == intPtrName)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.IntPtr);
}
else if (typeDefName == uintPtrName)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.UIntPtr);
}
else if (typeDefName == objectName)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Object);
}
else if (typeDefName == singleName)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Single);
}
else if (typeDefName == doubleName)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Double);
}
else if (typeDefName == typedReference)
{
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.TypedReference);
}
else if (typeDefName == enumName)
{
this.SystemEnum = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == valueTypeName)
{
this.SystemValueType = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == multicastDelegateName)
{
this.SystemMulticastDelegate = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == typeName)
{
this.SystemType = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
else if (typeDefName == paramArrayAttributeName)
{
this.SystemParamArrayAttribute = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
}
}
NamespaceReference systemNSR = peFileToObjectModel.GetNamespaceReferenceForString(coreAssemblyRef, nameTable.System);
if (this.SystemEnum == null || (peFileToObjectModel.SystemEnumAssembly != null && coreAssemblyRef != peFileToObjectModel.SystemEnumAssembly))
{
this.SystemEnum = peFileToObjectModel.typeCache.CreateCoreTypeReference(peFileToObjectModel.SystemEnumAssembly ?? coreAssemblyRef, systemNSR, nameTable.Enum, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
if (this.SystemValueType == null || (peFileToObjectModel.SystemValueTypeAssembly != null && coreAssemblyRef != peFileToObjectModel.SystemValueTypeAssembly))
{
this.SystemValueType = peFileToObjectModel.typeCache.CreateCoreTypeReference(peFileToObjectModel.SystemValueTypeAssembly ?? coreAssemblyRef, systemNSR, nameTable.ValueType, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
if (this.SystemMulticastDelegate == null || (peFileToObjectModel.SystemMulticastDelegateAssembly != null && coreAssemblyRef != peFileToObjectModel.SystemMulticastDelegateAssembly))
{
this.SystemMulticastDelegate = peFileToObjectModel.typeCache.CreateCoreTypeReference(peFileToObjectModel.SystemMulticastDelegateAssembly ?? coreAssemblyRef, systemNSR, nameTable.MulticastDelegate, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
if (this.SystemType == null || (peFileToObjectModel.SystemTypeAssembly != null && coreAssemblyRef != peFileToObjectModel.SystemTypeAssembly))
{
this.SystemType = peFileToObjectModel.typeCache.CreateCoreTypeReference(peFileToObjectModel.SystemTypeAssembly ?? coreAssemblyRef, systemNSR, nameTable.Type, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
if (this.SystemParamArrayAttribute == null || (peFileToObjectModel.SystemParamArrayAttributeAssembly != null && coreAssemblyRef != peFileToObjectModel.SystemParamArrayAttributeAssembly))
{
this.SystemParamArrayAttribute = peFileToObjectModel.typeCache.CreateCoreTypeReference(peFileToObjectModel.SystemParamArrayAttributeAssembly ?? coreAssemblyRef, systemNSR, peReader.ParamArrayAttribute, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
}
}
internal NamespaceBinder(Binder containingScope, NamespaceReference mergedContainer, IEnumerable <ImportedSymbol> imports)
: base(containingScope, mergedContainer, imports)
{
}
// Writing link text for unresolved simple references
internal static void WriteNamespaceReference(NamespaceReference space, ReferenceLinkDisplayOptions options,
XmlWriter writer)
{
writer.WriteString(space.Id.Substring(2));
}
public static Reference ReadReference(XmlReader reader)
{
if (reader == null || reader.NodeType != XmlNodeType.Element)
{
return(null);
}
switch (reader.Name)
{
case "InvalidReference":
InvalidReference invalidReference = new InvalidReference();
invalidReference.ReadXml(reader);
return(invalidReference);
case "NamespaceReference":
NamespaceReference namespaceReference = new NamespaceReference();
namespaceReference.ReadXml(reader);
return(namespaceReference);
case "ExtensionMethodReference":
ExtensionMethodReference extensionMethodReference = new ExtensionMethodReference();
extensionMethodReference.ReadXml(reader);
return(extensionMethodReference);
// For the MemberReference(s)...
case "SimpleMemberReference":
SimpleMemberReference simpleMemberReference = new SimpleMemberReference();
simpleMemberReference.ReadXml(reader);
return(simpleMemberReference);
case "SpecializedMemberReference":
SpecializedMemberReference specializedMemberReference = new SpecializedMemberReference();
specializedMemberReference.ReadXml(reader);
return(specializedMemberReference);
case "SpecializedMemberWithParametersReference":
SpecializedMemberWithParametersReference specializedMemberWithParametersReference
= new SpecializedMemberWithParametersReference();
specializedMemberWithParametersReference.ReadXml(reader);
return(specializedMemberWithParametersReference);
// For the TypeReference(s)...
case "SimpleTypeReference":
SimpleTypeReference simpleTypeReference = new SimpleTypeReference();
simpleTypeReference.ReadXml(reader);
return(simpleTypeReference);
case "SpecializedTypeReference":
SpecializedTypeReference specializedTypeReference = new SpecializedTypeReference();
specializedTypeReference.ReadXml(reader);
return(specializedTypeReference);
case "ArrayTypeReference":
ArrayTypeReference arrayTypeReference = new ArrayTypeReference();
arrayTypeReference.ReadXml(reader);
return(arrayTypeReference);
case "ReferenceTypeReference":
ReferenceTypeReference referenceTypeReference = new ReferenceTypeReference();
referenceTypeReference.ReadXml(reader);
return(referenceTypeReference);
case "PointerTypeReference":
PointerTypeReference pointerTypeReference = new PointerTypeReference();
pointerTypeReference.ReadXml(reader);
return(pointerTypeReference);
// For the TemplateTypeReference(s)...
case "IndexedTemplateTypeReference":
IndexedTemplateTypeReference indexedTemplateTypeReference =
new IndexedTemplateTypeReference();
indexedTemplateTypeReference.ReadXml(reader);
return(indexedTemplateTypeReference);
case "NamedTemplateTypeReference":
NamedTemplateTypeReference namedTemplateTypeReference = new NamedTemplateTypeReference();
namedTemplateTypeReference.ReadXml(reader);
return(namedTemplateTypeReference);
case "TypeTemplateTypeReference":
TypeTemplateTypeReference typeTemplateTypeReference = new TypeTemplateTypeReference();
typeTemplateTypeReference.ReadXml(reader);
return(typeTemplateTypeReference);
case "MethodTemplateTypeReference":
MethodTemplateTypeReference methodTemplateTypeReference = new MethodTemplateTypeReference();
methodTemplateTypeReference.ReadXml(reader);
return(methodTemplateTypeReference);
}
return(null);
}
/// <summary> /// Appends the specified namespace reference. /// </summary> /// <param name="namespaceReference">The namespace reference.</param> protected abstract void AppendNamespaceReference(NamespaceReference namespaceReference);
public void RemoveNamespaceImport(NamespaceReference import)
{
_NamespacesToRemove.Add(import);
}
/// <summary>
/// Appends the specified namespace reference.
/// </summary>
/// <param name="namespaceReference">The namespace reference.</param>
protected override void AppendNamespaceReference(NamespaceReference namespaceReference)
{
throw new NotImplementedException();
}
/// <summary>
/// Appends the specified namespace reference.
/// </summary>
/// <param name="namespaceReference">The namespace reference.</param>
protected override void AppendNamespaceReference(NamespaceReference namespaceReference)
{
Script.AppendFormat(CultureInfo.InvariantCulture, "using {0};", namespaceReference.Namespace);
Script.AppendLine();
}
private void HandleNamespaceImport(LanguageElement reference, string referenceFileName, NamespaceReference import, FileChangeGroup fileChangeGroup)
{
List<TypeDeclaration> typesFound = null;
if (_TypesFound.ContainsKey(referenceFileName))
typesFound = _TypesFound[referenceFileName]; // All the types (whose namespaces are changing) found in this file.
fileChangeGroup.PrepareForTrackingImports(referenceFileName);
List<TypeDeclaration> alreadyHandledImports = fileChangeGroup.GetHandledImports(referenceFileName);
List<string> newImportsNeeded = new List<string>();
foreach (TypeDeclaration typeDeclaration in typesFound)
{
if (alreadyHandledImports.IndexOf(typeDeclaration) < 0)
{
string expectedImport = GetExpectedNamespace(typeDeclaration.FileNode);
if (newImportsNeeded.IndexOf(expectedImport) < 0)
newImportsNeeded.Add(expectedImport);
alreadyHandledImports.Add(typeDeclaration);
}
}
for (int i = 0; i < newImportsNeeded.Count; i++)
{
bool isLast = i == newImportsNeeded.Count - 1;
fileChangeGroup.AddNewImport(import.Range.Start, newImportsNeeded[i], reference.FileNode, isLast);
}
fileChangeGroup.RemoveNamespaceImport(import);
}
//
// Lightweight check to see if a custom attribute's is of a well-known type.
//
// This check performs without instantating the Type object and bloating memory usage. On the flip side,
// it doesn't check on whether the type is defined in a paricular assembly. The desktop CLR typically doesn't
// check this either so this is useful from a compat persective as well.
//
public static bool IsCustomAttributeOfType(this CustomAttributeHandle customAttributeHandle,
MetadataReader reader,
String ns,
String name)
{
String[] namespaceParts = ns.Split('.');
Handle typeHandle = customAttributeHandle.GetCustomAttribute(reader).GetAttributeTypeHandle(reader);
HandleType handleType = typeHandle.HandleType;
if (handleType == HandleType.TypeDefinition)
{
TypeDefinition typeDefinition = typeHandle.ToTypeDefinitionHandle(reader).GetTypeDefinition(reader);
if (!typeDefinition.Name.StringEquals(name, reader))
{
return(false);
}
NamespaceDefinitionHandle nsHandle = typeDefinition.NamespaceDefinition;
int idx = namespaceParts.Length;
while (idx-- != 0)
{
String namespacePart = namespaceParts[idx];
NamespaceDefinition namespaceDefinition = nsHandle.GetNamespaceDefinition(reader);
if (!namespaceDefinition.Name.StringOrNullEquals(namespacePart, reader))
{
return(false);
}
if (!namespaceDefinition.ParentScopeOrNamespace.IsNamespaceDefinitionHandle(reader))
{
return(false);
}
nsHandle = namespaceDefinition.ParentScopeOrNamespace.ToNamespaceDefinitionHandle(reader);
}
if (!nsHandle.GetNamespaceDefinition(reader).Name.StringOrNullEquals(null, reader))
{
return(false);
}
return(true);
}
else if (handleType == HandleType.TypeReference)
{
TypeReference typeReference = typeHandle.ToTypeReferenceHandle(reader).GetTypeReference(reader);
if (!typeReference.TypeName.StringEquals(name, reader))
{
return(false);
}
if (!typeReference.ParentNamespaceOrType.IsNamespaceReferenceHandle(reader))
{
return(false);
}
NamespaceReferenceHandle nsHandle = typeReference.ParentNamespaceOrType.ToNamespaceReferenceHandle(reader);
int idx = namespaceParts.Length;
while (idx-- != 0)
{
String namespacePart = namespaceParts[idx];
NamespaceReference namespaceReference = nsHandle.GetNamespaceReference(reader);
if (!namespaceReference.Name.StringOrNullEquals(namespacePart, reader))
{
return(false);
}
if (!namespaceReference.ParentScopeOrNamespace.IsNamespaceReferenceHandle(reader))
{
return(false);
}
nsHandle = namespaceReference.ParentScopeOrNamespace.ToNamespaceReferenceHandle(reader);
}
if (!nsHandle.GetNamespaceReference(reader).Name.StringOrNullEquals(null, reader))
{
return(false);
}
return(true);
}
else
{
throw new NotSupportedException();
}
}
/// <summary>
/// Appends the specified namespace reference.
/// </summary>
/// <param name="namespaceReference">The namespace reference.</param>
protected override void AppendNamespaceReference(NamespaceReference namespaceReference)
{
Script.AppendFormat(CultureInfo.InvariantCulture, "using {0};", namespaceReference.Namespace);
Script.AppendLine();
}
