コード例 #1
0
ファイル: MinimalCorlib.cs プロジェクト: z3nth10n/ILSpy-CMD
        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();
        }
コード例 #2
0
        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));
            }
        }
コード例 #3
0
            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 : "");
            }
コード例 #4
0
 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);
     }
 }
コード例 #5
0
ファイル: PrimitiveType.cs プロジェクト: xinjianlv/dotfiles
        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));
            }
        }
コード例 #6
0
 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);
         }
     }
 }
コード例 #7
0
        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));
            }
        }
コード例 #8
0
        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));
        }
コード例 #9
0
        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);
            }
        }
コード例 #10
0
ファイル: SRMExtensions.cs プロジェクト: zwkjgs/ILSpy
 public static bool IsKnownType(this EntityHandle handle, MetadataReader reader,
                                KnownTypeCode knownType)
 {
     return(!handle.IsNil &&
            GetFullTypeName(handle, reader) == KnownTypeReference.Get(knownType).TypeName);
 }
コード例 #11
0
 public CorlibTypeDefinition(MinimalCorlib corlib, KnownTypeCode typeCode)
 {
     this.corlib   = corlib;
     this.typeCode = typeCode;
     this.typeKind = KnownTypeReference.Get(typeCode).typeKind;
 }
コード例 #12
0
ファイル: BamlResourceEntryNode.cs プロジェクト: zwkjgs/ILSpy
            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);
                }
            }