public override MetadataType GetType(string nameSpace, string name, NotFoundBehavior notFoundBehavior)
                {
                    TypeSystemContext context = Context;

                    if (context.SupportsCanon && (nameSpace == context.CanonType.Namespace) && (name == context.CanonType.Name))
                    {
                        return(Context.CanonType);
                    }
                    if (context.SupportsUniversalCanon && (nameSpace == context.UniversalCanonType.Namespace) && (name == context.UniversalCanonType.Name))
                    {
                        return(Context.UniversalCanonType);
                    }
                    else
                    {
                        if (notFoundBehavior != NotFoundBehavior.ReturnNull)
                        {
                            var failure = ResolutionFailure.GetTypeLoadResolutionFailure(nameSpace, name, "System.Private.Canon");
                            ModuleDesc.GetTypeResolutionFailure = failure;
                            if (notFoundBehavior == NotFoundBehavior.Throw)
                            {
                                failure.Throw();
                            }

                            return(null);
                        }
                        return(null);
                    }
                }
Esempio n. 2
0
        private Object ResolveTypeReference(TypeReferenceHandle handle)
        {
            TypeReference typeReference = _metadataReader.GetTypeReference(handle);

            Object resolutionScope = GetObject(typeReference.ResolutionScope, NotFoundBehavior.ReturnResolutionFailure);

            if (resolutionScope is ResolutionFailure)
            {
                return(resolutionScope);
            }

            if (resolutionScope is ModuleDesc)
            {
                return(((ModuleDesc)(resolutionScope)).GetType(_metadataReader.GetString(typeReference.Namespace), _metadataReader.GetString(typeReference.Name), NotFoundBehavior.ReturnResolutionFailure));
            }
            else
            if (resolutionScope is MetadataType)
            {
                string typeName = _metadataReader.GetString(typeReference.Name);
                if (!typeReference.Namespace.IsNil)
                {
                    typeName = _metadataReader.GetString(typeReference.Namespace) + "." + typeName;
                }
                MetadataType result = ((MetadataType)(resolutionScope)).GetNestedType(typeName);
                if (result != null)
                {
                    return(result);
                }

                return(ResolutionFailure.GetTypeLoadResolutionFailure(typeName, ((MetadataType)resolutionScope).Module));
            }

            // TODO
            throw new NotImplementedException();
        }
Esempio n. 3
0
        private Object ResolveAssemblyReference(AssemblyReferenceHandle handle)
        {
            AssemblyReference assemblyReference = _metadataReader.GetAssemblyReference(handle);

            AssemblyName an = new AssemblyName();

            an.Name    = _metadataReader.GetString(assemblyReference.Name);
            an.Version = assemblyReference.Version;

            var publicKeyOrToken = _metadataReader.GetBlobBytes(assemblyReference.PublicKeyOrToken);

            if ((assemblyReference.Flags & AssemblyFlags.PublicKey) != 0)
            {
                an.SetPublicKey(publicKeyOrToken);
            }
            else
            {
                an.SetPublicKeyToken(publicKeyOrToken);
            }

            an.CultureName = _metadataReader.GetString(assemblyReference.Culture);
            an.ContentType = GetContentTypeFromAssemblyFlags(assemblyReference.Flags);

            var assembly = _moduleResolver.ResolveAssembly(an, throwIfNotFound: false);

            if (assembly == null)
            {
                return(ResolutionFailure.GetAssemblyResolutionFailure(an.Name));
            }
            else
            {
                return(assembly);
            }
        }
Esempio n. 4
0
        private Object ResolveExportedType(ExportedTypeHandle handle)
        {
            ExportedType exportedType = _metadataReader.GetExportedType(handle);

            var implementation = GetObject(exportedType.Implementation, NotFoundBehavior.ReturnResolutionFailure);

            if (implementation is ModuleDesc)
            {
                var    module    = (ModuleDesc)implementation;
                string nameSpace = _metadataReader.GetString(exportedType.Namespace);
                string name      = _metadataReader.GetString(exportedType.Name);
                return(module.GetType(nameSpace, name, NotFoundBehavior.ReturnResolutionFailure));
            }
            else
            if (implementation is MetadataType)
            {
                var    type       = (MetadataType)implementation;
                string name       = _metadataReader.GetString(exportedType.Name);
                var    nestedType = type.GetNestedType(name);
                if (nestedType == null)
                {
                    return(ResolutionFailure.GetTypeLoadResolutionFailure(name, this));
                }
                return(nestedType);
            }
            else if (implementation is ResolutionFailure)
            {
                return(implementation);
            }
            else
            {
                ThrowHelper.ThrowBadImageFormatException();
                return(null);
            }
        }
Esempio n. 5
0
 void SetResolutionFailure(ResolutionFailure failure)
 {
     if (_resolutionFailure == null)
     {
         _resolutionFailure = failure;
     }
 }
Esempio n. 6
0
        public static ResolutionFailure GetAssemblyResolutionFailure(string simpleName)
        {
            ResolutionFailure failure = new ResolutionFailure();

            failure._failureType = FailureType.MissingAssemblyException1;
            failure._name        = simpleName;
            return(failure);
        }
Esempio n. 7
0
        public static ResolutionFailure GetTypeLoadResolutionFailure(string nestedTypeName, ModuleDesc module)
        {
            ResolutionFailure failure = new ResolutionFailure();

            failure._failureType = FailureType.TypeLoadException1;
            failure._name        = nestedTypeName;
            failure._module      = module;
            return(failure);
        }
Esempio n. 8
0
        public static ResolutionFailure GetMissingFieldFailure(TypeDesc owningType, string fieldName)
        {
            ResolutionFailure failure = new ResolutionFailure();

            failure._failureType = FailureType.MissingMethodException1;
            failure._name        = fieldName;
            failure._owningType  = owningType;
            return(failure);
        }
Esempio n. 9
0
        public static ResolutionFailure GetMissingMethodFailure(TypeDesc owningType, string methodName, MethodSignature signature)
        {
            ResolutionFailure failure = new ResolutionFailure();

            failure._failureType     = FailureType.MissingMethodException1;
            failure._methodSignature = signature;
            failure._name            = methodName;
            failure._owningType      = owningType;
            return(failure);
        }
Esempio n. 10
0
        public static ResolutionFailure GetTypeLoadResolutionFailure(string @namespace, string name, string moduleName)
        {
            ResolutionFailure failure = new ResolutionFailure();

            failure._failureType = FailureType.TypeLoadException3;
            failure._namespace   = @namespace;
            failure._name        = name;
            failure._moduleName  = moduleName;
            return(failure);
        }
Esempio n. 11
0
 public EcmaSignatureParser(EcmaModule ecmaModule, BlobReader reader, NotFoundBehavior notFoundBehavior)
 {
     _notFoundBehavior = notFoundBehavior;
     _ecmaModule       = ecmaModule;
     _tsc          = ecmaModule.Context;
     _typeResolver = null;
     _reader       = reader;
     _indexStack   = null;
     _embeddedSignatureDataList = null;
     _resolutionFailure         = null;
 }
Esempio n. 12
0
 public EcmaSignatureParser(TypeSystemContext tsc, Func <EntityHandle, NotFoundBehavior, TypeDesc> typeResolver, BlobReader reader, NotFoundBehavior notFoundBehavior)
 {
     _notFoundBehavior = notFoundBehavior;
     _ecmaModule       = null;
     _tsc          = tsc;
     _typeResolver = typeResolver;
     _reader       = reader;
     _indexStack   = null;
     _embeddedSignatureDataList = null;
     _resolutionFailure         = null;
 }
Esempio n. 13
0
        public override object GetType(string nameSpace, string name, NotFoundBehavior notFoundBehavior)
        {
            MetadataType type = GetTypeInternal(nameSpace, name);

            if ((type == null) && notFoundBehavior != NotFoundBehavior.ReturnNull)
            {
                ResolutionFailure failure = ResolutionFailure.GetTypeLoadResolutionFailure(nameSpace, name, this);
                if (notFoundBehavior == NotFoundBehavior.Throw)
                {
                    failure.Throw();
                }
                return(failure);
            }
            return(type);
        }
 private static Exception ReportOverloadResolutionFailure(string OverloadedProcedureName, List<Symbols.Method> Candidates, object[] Arguments, string[] ArgumentNames, Type[] TypeArguments, string ErrorID, ResolutionFailure Failure, ArgumentDetector Detector, CandidateProperty CandidateFilter)
 {
     StringBuilder builder = new StringBuilder();
     List<string> errors = new List<string>();
     int num = 0;
     int num4 = Candidates.Count - 1;
     for (int i = 0; i <= num4; i++)
     {
         Symbols.Method candidate = Candidates[i];
         if (CandidateFilter(candidate))
         {
             if (candidate.HasParamArray)
             {
                 for (int j = i + 1; j < Candidates.Count; j++)
                 {
                     if (CandidateFilter(Candidates[j]) && (Candidates[j] == candidate))
                     {
                         continue;
                     }
                 }
             }
             num++;
             errors.Clear();
             bool flag = Detector(candidate, Arguments, ArgumentNames, TypeArguments, errors);
             builder.Append("\r\n    '");
             builder.Append(candidate.ToString());
             builder.Append("':");
             foreach (string str2 in errors)
             {
                 builder.Append("\r\n        ");
                 builder.Append(str2);
             }
         }
     }
     string resourceString = Utils.GetResourceString(ErrorID, new string[] { OverloadedProcedureName, builder.ToString() });
     if (num == 1)
     {
         return new InvalidCastException(resourceString);
     }
     return new AmbiguousMatchException(resourceString);
 }
 private static Exception ReportUnspecificProcedures(string OverloadedProcedureName, List<Symbols.Method> Candidates, ResolutionFailure Failure)
 {
     return ReportOverloadResolutionFailure(OverloadedProcedureName, Candidates, null, null, null, "NoMostSpecificOverload2", Failure, new ArgumentDetector(OverloadResolution.DetectUnspecificity), new CandidateProperty(OverloadResolution.CandidateIsUnspecific));
 }
        internal static Symbols.Method ResolveOverloadedCall(string MethodName, List<Symbols.Method> Candidates, object[] Arguments, string[] ArgumentNames, Type[] TypeArguments, BindingFlags LookupFlags, bool ReportErrors, ref ResolutionFailure Failure)
        {
            Failure = ResolutionFailure.None;
            int count = Candidates.Count;
            bool someCandidatesAreGeneric = false;
            Symbols.Method method = RejectUncallableProcedures(Candidates, Arguments, ArgumentNames, TypeArguments, ref count, ref someCandidatesAreGeneric);
            switch (count)
            {
                case 1:
                    return method;

                case 0:
                    Failure = ResolutionFailure.InvalidArgument;
                    if (ReportErrors)
                    {
                        throw ReportUncallableProcedures(MethodName, Candidates, Arguments, ArgumentNames, TypeArguments, Failure);
                    }
                    return null;
            }
            if (someCandidatesAreGeneric)
            {
                method = RemoveRedundantGenericProcedures(Candidates, ref count, Arguments, ArgumentNames);
                if (count == 1)
                {
                    return method;
                }
            }
            int num2 = 0;
            Symbols.Method method2 = null;
            foreach (Symbols.Method method4 in Candidates)
            {
                if (!method4.NotCallable)
                {
                    if (method4.RequiresNarrowingConversion)
                    {
                        count--;
                        if (method4.AllNarrowingIsFromObject)
                        {
                            num2++;
                            method2 = method4;
                        }
                    }
                    else
                    {
                        method = method4;
                    }
                }
            }
            switch (count)
            {
                case 1:
                    return method;

                case 0:
                    if (num2 == 1)
                    {
                        return method2;
                    }
                    Failure = ResolutionFailure.AmbiguousMatch;
                    if (ReportErrors)
                    {
                        throw ReportNarrowingProcedures(MethodName, Candidates, Arguments, ArgumentNames, TypeArguments, Failure);
                    }
                    return null;
            }
            method = MostSpecificProcedure(Candidates, ref count, Arguments, ArgumentNames);
            if (method != null)
            {
                return method;
            }
            Failure = ResolutionFailure.AmbiguousMatch;
            if (ReportErrors)
            {
                throw ReportUnspecificProcedures(MethodName, Candidates, Failure);
            }
            return null;
        }
Esempio n. 17
0
        private Object ResolveMemberReference(MemberReferenceHandle handle)
        {
            MemberReference memberReference = _metadataReader.GetMemberReference(handle);

            Object parent = GetObject(memberReference.Parent, NotFoundBehavior.ReturnResolutionFailure);

            if (parent is ResolutionFailure)
            {
                return(parent);
            }

            TypeDesc parentTypeDesc = parent as TypeDesc;

            if (parentTypeDesc != null)
            {
                BlobReader signatureReader = _metadataReader.GetBlobReader(memberReference.Signature);

                EcmaSignatureParser parser = new EcmaSignatureParser(this, signatureReader, NotFoundBehavior.ReturnResolutionFailure);

                string name = _metadataReader.GetString(memberReference.Name);

                if (parser.IsFieldSignature)
                {
                    FieldDesc field = parentTypeDesc.GetField(name);
                    if (field != null)
                    {
                        return(field);
                    }

                    return(ResolutionFailure.GetMissingFieldFailure(parentTypeDesc, name));
                }
                else
                {
                    MethodSignature sig = parser.ParseMethodSignature();
                    if (sig == null)
                    {
                        return(parser.ResolutionFailure);
                    }
                    TypeDesc      typeDescToInspect = parentTypeDesc;
                    Instantiation substitution      = default(Instantiation);

                    // Try to resolve the name and signature in the current type, or any of the base types.
                    do
                    {
                        MethodDesc method = typeDescToInspect.GetMethod(name, sig, substitution);
                        if (method != null)
                        {
                            // If this resolved to one of the base types, make sure it's not a constructor.
                            // Instance constructors are not inherited.
                            if (typeDescToInspect != parentTypeDesc && method.IsConstructor)
                            {
                                break;
                            }

                            return(method);
                        }
                        var baseType = typeDescToInspect.BaseType;
                        if (baseType != null)
                        {
                            if (!baseType.HasInstantiation)
                            {
                                substitution = default(Instantiation);
                            }
                            else
                            {
                                // If the base type is generic, any signature match for methods on the base type with the generic details from
                                // the deriving type
                                Instantiation newSubstitution = typeDescToInspect.GetTypeDefinition().BaseType.Instantiation;
                                if (!substitution.IsNull)
                                {
                                    TypeDesc[] newSubstitutionTypes = new TypeDesc[newSubstitution.Length];
                                    for (int i = 0; i < newSubstitution.Length; i++)
                                    {
                                        newSubstitutionTypes[i] = newSubstitution[i].InstantiateSignature(substitution, default(Instantiation));
                                    }
                                    newSubstitution = new Instantiation(newSubstitutionTypes);
                                }
                                substitution = newSubstitution;
                            }
                        }
                        typeDescToInspect = baseType;
                    } while (typeDescToInspect != null);

                    return(ResolutionFailure.GetMissingMethodFailure(parentTypeDesc, name, sig));
                }
            }
            else if (parent is MethodDesc)
            {
                ThrowHelper.ThrowInvalidProgramException(ExceptionStringID.InvalidProgramVararg, (MethodDesc)parent);
            }
            else if (parent is ModuleDesc)
            {
                throw new NotImplementedException("MemberRef to a global function or variable.");
            }

            ThrowHelper.ThrowBadImageFormatException();
            return(null);
        }
Esempio n. 18
0
        public sealed override MetadataType GetType(string nameSpace, string name, NotFoundBehavior notFoundBehavior)
        {
            var stringComparer = _metadataReader.StringComparer;

            // TODO: More efficient implementation?
            foreach (var typeDefinitionHandle in _metadataReader.TypeDefinitions)
            {
                var typeDefinition = _metadataReader.GetTypeDefinition(typeDefinitionHandle);
                if (stringComparer.Equals(typeDefinition.Name, name) &&
                    stringComparer.Equals(typeDefinition.Namespace, nameSpace))
                {
                    return((MetadataType)GetType((EntityHandle)typeDefinitionHandle));
                }
            }

            foreach (var exportedTypeHandle in _metadataReader.ExportedTypes)
            {
                var exportedType = _metadataReader.GetExportedType(exportedTypeHandle);
                if (stringComparer.Equals(exportedType.Name, name) &&
                    stringComparer.Equals(exportedType.Namespace, nameSpace))
                {
                    if (exportedType.IsForwarder)
                    {
                        Object implementation = GetObject(exportedType.Implementation, notFoundBehavior);

                        if (implementation == null)
                        {
                            return(null);
                        }

                        if (implementation is ModuleDesc)
                        {
                            return(((ModuleDesc)(implementation)).GetType(nameSpace, name));
                        }
                        else if (implementation is ResolutionFailure failure)
                        {
                            ModuleDesc.GetTypeResolutionFailure = failure;
                            return(null);
                        }

                        // TODO
                        throw new NotImplementedException();
                    }
                    // TODO:
                    throw new NotImplementedException();
                }
            }

            if (notFoundBehavior != NotFoundBehavior.ReturnNull)
            {
                var failure = ResolutionFailure.GetTypeLoadResolutionFailure(nameSpace, name, this);
                if (notFoundBehavior == NotFoundBehavior.Throw)
                {
                    failure.Throw();
                }

                ModuleDesc.GetTypeResolutionFailure = failure;
                return(null);
            }

            return(null);
        }
 internal static Symbols.Method ResolveOverloadedCall(string MethodName, MemberInfo[] Members, object[] Arguments, string[] ArgumentNames, Type[] TypeArguments, BindingFlags LookupFlags, bool ReportErrors, ref ResolutionFailure Failure)
 {
     int rejectedForArgumentCount = 0;
     int rejectedForTypeArgumentCount = 0;
     List<Symbols.Method> candidates = CollectOverloadCandidates(Members, Arguments, Arguments.Length, ArgumentNames, TypeArguments, false, null, ref rejectedForArgumentCount, ref rejectedForTypeArgumentCount);
     if ((candidates.Count == 1) && !candidates[0].NotCallable)
     {
         return candidates[0];
     }
     if (candidates.Count != 0)
     {
         return ResolveOverloadedCall(MethodName, candidates, Arguments, ArgumentNames, TypeArguments, LookupFlags, ReportErrors, ref Failure);
     }
     Failure = ResolutionFailure.MissingMember;
     if (!ReportErrors)
     {
         return null;
     }
     string resourceKey = "NoViableOverloadCandidates1";
     if (rejectedForArgumentCount > 0)
     {
         resourceKey = "NoArgumentCountOverloadCandidates1";
     }
     else if (rejectedForTypeArgumentCount > 0)
     {
         resourceKey = "NoTypeArgumentCountOverloadCandidates1";
     }
     throw new MissingMemberException(Utils.GetResourceString(resourceKey, new string[] { MethodName }));
 }
Esempio n. 20
0
        public sealed override object GetType(string nameSpace, string name, NotFoundBehavior notFoundBehavior)
        {
            var currentModule = this;

            // src/coreclr/vm/clsload.cpp use the same restriction to detect a loop in the type forwarding.
            for (int typeForwardingChainSize = 0; typeForwardingChainSize <= 1024; typeForwardingChainSize++)
            {
                var metadataReader = currentModule._metadataReader;
                var stringComparer = metadataReader.StringComparer;
                // TODO: More efficient implementation?
                foreach (var typeDefinitionHandle in metadataReader.TypeDefinitions)
                {
                    var typeDefinition = metadataReader.GetTypeDefinition(typeDefinitionHandle);
                    if (stringComparer.Equals(typeDefinition.Name, name) &&
                        stringComparer.Equals(typeDefinition.Namespace, nameSpace))
                    {
                        return(currentModule.GetType(typeDefinitionHandle));
                    }
                }

                foreach (var exportedTypeHandle in metadataReader.ExportedTypes)
                {
                    var exportedType = metadataReader.GetExportedType(exportedTypeHandle);
                    if (stringComparer.Equals(exportedType.Name, name) &&
                        stringComparer.Equals(exportedType.Namespace, nameSpace))
                    {
                        if (exportedType.IsForwarder)
                        {
                            object implementation = currentModule.GetObject(exportedType.Implementation, notFoundBehavior);

                            if (implementation == null)
                            {
                                return(null);
                            }
                            if (implementation is EcmaModule ecmaModule)
                            {
                                currentModule = ecmaModule;
                                break;
                            }
                            if (implementation is ModuleDesc moduleDesc)
                            {
                                return(moduleDesc.GetType(nameSpace, name, notFoundBehavior));
                            }
                            if (implementation is ResolutionFailure failure)
                            {
                                // No need to check notFoundBehavior - the callee already handled ReturnNull and Throw
                                return(implementation);
                            }
                            // TODO
                            throw new NotImplementedException();
                        }

                        // TODO:
                        throw new NotImplementedException();
                    }
                }
            }

            if (notFoundBehavior != NotFoundBehavior.ReturnNull)
            {
                var failure = ResolutionFailure.GetTypeLoadResolutionFailure(nameSpace, name, this);
                if (notFoundBehavior == NotFoundBehavior.Throw)
                {
                    failure.Throw();
                }

                return(failure);
            }

            return(null);
        }
 private static Exception ReportUncallableProcedures(string OverloadedProcedureName, List<Symbols.Method> Candidates, object[] Arguments, string[] ArgumentNames, Type[] TypeArguments, ResolutionFailure Failure)
 {
     return ReportOverloadResolutionFailure(OverloadedProcedureName, Candidates, Arguments, ArgumentNames, TypeArguments, "NoCallableOverloadCandidates2", Failure, new ArgumentDetector(OverloadResolution.DetectArgumentErrors), new CandidateProperty(OverloadResolution.CandidateIsNotCallable));
 }