public static IAssemblyReference GetAssemblyReference(IType value) { ITypeReference typeReference = value as ITypeReference; if (typeReference != null) { ITypeReference declaringType = typeReference.Owner as ITypeReference; if (declaringType != null) { return(GetAssemblyReference(declaringType)); } IModuleReference moduleReference = typeReference.Owner as IModuleReference; if (moduleReference != null) { IModule module = moduleReference.Resolve(); return(module.Assembly); } IAssemblyReference assemblyReference = typeReference.Owner as IAssemblyReference; if (assemblyReference != null) { return(assemblyReference); } } throw new NotSupportedException(); }
protected void Init(IModuleReference mainAssembly, IEnumerable <IModuleReference> assemblyReferences) { if (mainAssembly == null) { throw new ArgumentNullException(nameof(mainAssembly)); } if (assemblyReferences == null) { throw new ArgumentNullException(nameof(assemblyReferences)); } var context = new SimpleTypeResolveContext(this); this.mainModule = mainAssembly.Resolve(context); List <IModule> assemblies = new List <IModule>(); assemblies.Add(this.mainModule); List <IModule> referencedAssemblies = new List <IModule>(); foreach (var asmRef in assemblyReferences) { IModule asm; try { asm = asmRef.Resolve(context); } catch (InvalidOperationException) { throw new InvalidOperationException("Tried to initialize compilation with an invalid assembly reference. (Forgot to load the assembly reference ? - see CecilLoader)"); } if (asm != null && !assemblies.Contains(asm)) { assemblies.Add(asm); } if (asm != null && !referencedAssemblies.Contains(asm)) { referencedAssemblies.Add(asm); } } this.assemblies = assemblies.AsReadOnly(); this.referencedAssemblies = referencedAssemblies.AsReadOnly(); this.knownTypeCache = new KnownTypeCache(this); this.initialized = true; }
public IType Resolve(ITypeResolveContext context) { if (context == null) { throw new ArgumentNullException("context"); } IType type = null; if (module == null) { // No assembly specified: look in all assemblies, but prefer the current assembly if (context.CurrentModule != null) { type = context.CurrentModule.GetTypeDefinition(fullTypeName); } if (type == null) { type = ResolveInAllAssemblies(context); } } else { // Assembly specified: only look in the specified assembly. // But if that's not loaded in the compilation, allow fall back to other assemblies. // (the non-loaded assembly might be a facade containing type forwarders - // for example, when referencing a portable library from a non-portable project) IModule asm = module.Resolve(context); if (asm != null) { type = asm.GetTypeDefinition(fullTypeName); } else { type = ResolveInAllAssemblies(context); } } return(type ?? new UnknownType(fullTypeName, isReferenceType)); }
public static IAssemblyReference GetAssemblyReference(IType value) { ITypeReference reference = value as ITypeReference; if (reference != null) { ITypeReference owner = reference.Owner as ITypeReference; if (owner != null) { return(GetAssemblyReference(owner)); } IModuleReference reference4 = reference.Owner as IModuleReference; if (reference4 != null) { return(reference4.Resolve().Assembly); } IAssemblyReference reference3 = reference.Owner as IAssemblyReference; if (reference3 != null) { return(reference3); } } throw new NotSupportedException(); }
private IAssemblyReference GetAssemblyReference(ITypeReference value) { if (value.Owner is ITypeReference) { return(this.GetAssemblyReference(value.Owner as ITypeReference)); } else if (value.Owner is IAssemblyReference) { return(value.Owner as IAssemblyReference); } else if (value.Owner is IModuleReference) { IModuleReference moduleReference = (IModuleReference)value.Owner; IModule module = moduleReference.Resolve(); if (module != null) { return(module.Assembly); } return(null); } throw new NotSupportedException("Unable to get assembly reference for type of code identifier."); }
private TreeNode FindNode(IMemberReference memberReference) { if (memberReference is IAssemblyReference) { foreach (TreeNode node in _assembliesTree.Nodes) { if (node.Tag == memberReference) { return(node); } } return(null); } if (memberReference is IResourceReference) { IResourceReference resourceReference = (IResourceReference)memberReference; TreeNode assemblyNode = FindNode(resourceReference.Resolve().Assembly); TreeNode resourcesNode = null; foreach (TreeNode childNode in assemblyNode.Nodes) { if (childNode.Text == "Resources") { resourcesNode = childNode; } } return(FindNode(memberReference, resourcesNode)); } if (memberReference is IModuleReference) { IModuleReference moduleReference = (IModuleReference)memberReference; return(FindNode(memberReference, FindNode(moduleReference.Resolve().Assembly))); } if (memberReference is ITypeReference) { ITypeReference typeReference = (ITypeReference)memberReference; if (typeReference.Resolve().DeclaringType != null) { TreeNode declaringTypeNode = FindNode(typeReference.Resolve().DeclaringType); return(FindNode(memberReference, declaringTypeNode)); } else { TreeNode moduleNode = FindNode(typeReference.Resolve().Module); foreach (TreeNode namespaceNode in moduleNode.Nodes) { if (((namespaceNode.Text == "-") && (typeReference.Namespace == null)) || (namespaceNode.Text == typeReference.Namespace)) { return(FindNode(memberReference, namespaceNode)); } } } return(null); } if (memberReference is IMethodReference) { IMethodReference methodReference = (IMethodReference)memberReference; TreeNode typeNode = FindNode(methodReference.Resolve().DeclaringType); if (typeNode == null) { return(null); } foreach (TreeNode node in typeNode.Nodes) { if (node.Tag == memberReference) { return(node); } if ((node.Tag is IPropertyReference) || (node.Tag is IEventReference)) { TreeNode nestedEventNode = FindNode(memberReference, node); if (nestedEventNode != null) { return(nestedEventNode); } } } return(null); } if (memberReference is IFieldReference) { IFieldReference fieldReference = (IFieldReference)memberReference; return(FindNode(memberReference, FindNode(fieldReference.Resolve().DeclaringType))); } if (memberReference is IPropertyReference) { IPropertyReference propertyReference = (IPropertyReference)memberReference; return(FindNode(memberReference, FindNode(propertyReference.Resolve().DeclaringType))); } if (memberReference is IEventReference) { IEventReference eventReference = (IEventReference)memberReference; return(FindNode(memberReference, FindNode(eventReference.Resolve().DeclaringType))); } return(null); }