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); } }
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(); }
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); } }
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); } }
void SetResolutionFailure(ResolutionFailure failure) { if (_resolutionFailure == null) { _resolutionFailure = failure; } }
public static ResolutionFailure GetAssemblyResolutionFailure(string simpleName) { ResolutionFailure failure = new ResolutionFailure(); failure._failureType = FailureType.MissingAssemblyException1; failure._name = simpleName; return(failure); }
public static ResolutionFailure GetTypeLoadResolutionFailure(string nestedTypeName, ModuleDesc module) { ResolutionFailure failure = new ResolutionFailure(); failure._failureType = FailureType.TypeLoadException1; failure._name = nestedTypeName; failure._module = module; return(failure); }
public static ResolutionFailure GetMissingFieldFailure(TypeDesc owningType, string fieldName) { ResolutionFailure failure = new ResolutionFailure(); failure._failureType = FailureType.MissingMethodException1; failure._name = fieldName; failure._owningType = owningType; return(failure); }
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); }
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); }
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; }
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; }
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; }
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); }
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 })); }
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)); }