/*?*/ protected TypeName ConvertToTypeName( string serializedTypeName ) { TypeNameParser typeNameParser = new TypeNameParser(this.PEFileToObjectModel.NameTable, serializedTypeName); TypeName/*?*/ typeName = typeNameParser.ParseTypeName(); return typeName; }
public void SimpleType() { var type = typeof(string); var typeReference = TypeNameParser.ParseType(null, type.AssemblyQualifiedName); Utilities.ValidateType(type, typeReference); Utilities.ValidateAssembly(new ReflectionAssemblyNameWrapper(type.Assembly.GetName()), typeReference.ResolutionScope as AssemblyReference); }
public void NestedType() { var type = typeof(DebuggableAttribute.DebuggingModes); var typeReference = TypeNameParser.ParseType(null, type.AssemblyQualifiedName); Utilities.ValidateType(type, typeReference); Utilities.ValidateAssembly(new ReflectionAssemblyNameWrapper(type.Assembly.GetName()), typeReference.GetElementType().DeclaringTypeDescriptor.ResolutionScope as AssemblyReference); }
public void ParseWithDefaultNamespaceAndAssembly() { const string defaultAssembly = "DefaultAssembly"; const string defaultNamespace = "DefaultNamespace"; AssemblyQualifiedTypeName tn = TypeNameParser.Parse("SomeType", defaultNamespace, defaultAssembly); Assert.AreEqual("DefaultNamespace.SomeType", tn.Type); }
/// <summary> /// Converts a partial class name into a fully one /// </summary> /// <param name="className"></param> /// <param name="mappings"></param> /// <returns>The class FullName (without the assembly)</returns> /// <remarks> /// The FullName is equivalent to the default entity-name /// </remarks> protected static string FullClassName(string className, Mappings mappings) { if (className == null) { return(null); } return(TypeNameParser.Parse(className, mappings.DefaultNamespace, mappings.DefaultAssembly).Type); }
public void ParseWithDefaultNamespaceNoAssembly() { const string defaultNamespace = "DefaultNamespace"; AssemblyQualifiedTypeName tn = TypeNameParser.Parse("SomeType", defaultNamespace, null); Assert.AreEqual("DefaultNamespace.SomeType", tn.Type); Assert.IsNull(tn.Assembly); }
private static Attribute ConvertToRule(XmlNhvmRuleConverterArgs rule) { NhvmRule ruleRule = (NhvmRule)rule.schemaRule; string attribute = ruleRule.attribute; AssemblyQualifiedTypeName fullClassName = TypeNameParser.Parse(attribute, rule.defaultNameSpace, rule.defaultAssembly); System.Type type = ReflectHelper.ClassForFullName(fullClassName.ToString()); #if NETFX log.Info("The type found for ruleRule = " + type.FullName); #else Log.Info("The type found for ruleRule = {0}", type.FullName); #endif Attribute thisattribute = (Attribute)Activator.CreateInstance(type); #if NETFX log.Info("Attribute found = " + thisattribute); #else Log.Info("Attribute found = {0}", thisattribute); #endif var tr = thisattribute as ITagableRule; if (tr != null) { AssignTagsFromString(tr, ruleRule.tags); } if (ruleRule.param == null) { return(thisattribute); //eager return } foreach (NhvmParam parameter in ruleRule.param) { PropertyInfo propInfo = type.GetProperty(parameter.name); if (propInfo != null) { #if NETFX log.Info("propInfo value = " + parameter.value); #else Log.Info("propInfo value = {0}", parameter.value); #endif object value = propInfo.PropertyType != typeof(string) ? Convert.ChangeType(parameter.value, propInfo.PropertyType) : parameter.value; propInfo.SetValue(thisattribute, value, null); } else { throw new InvalidPropertyNameException( string.Format("The custom attribute '{0}' don't have the property '{1}'; Check for typo.", type.FullName, parameter.name), parameter.name, type); } } return(thisattribute); }
public void ReadTypeInCorLibAssemblyWithoutScope() { const string ns = "System"; const string name = "Array"; var expected = new TypeReference(_module.CorLibTypeFactory.CorLibScope, ns, name).ToTypeSignature(); var actual = TypeNameParser.Parse(_module, $"{ns}.{name}"); Assert.Equal(expected, actual, _comparer); }
public void UpdateFrom(TypeDiscoveredMessage message) { var typeModel = message.TypeModel; var typeData = new TypeData( typeModel.Id, TypeNameParser.ParseAssemblyQualifiedTypeName(typeModel.AssemblyQualifiedName), typeModel.IsDisposable); _typeData.Add(typeData); }
public void NestedClasses() { var input = "Db4oPad.TestDBs.NestedClasses+ChildClass, Db4oPad.TestDBs"; var result = TypeNameParser.ParseString(input); Assert.AreEqual("Db4oPad.TestDBs.NestedClasses+ChildClass", result.NameAndNamespace); Assert.AreEqual("Db4oPad.TestDBs", result.AssemblyName); Assert.AreEqual(input, result.FullName); Assert.AreEqual("ChildClass", result.Name); }
public void MultiNestedGeneric() { var input = "Gamlor.Db4oPad.Tests.TypeGeneration.Generic`2[[System.String, mscorlib], [System.Collections.Generic.List`1[[System.String, mscorlib]], mscorlib]], Gamlor.Db4oPad.Tests"; var result = TypeNameParser.ParseString(input); Assert.AreEqual("Gamlor.Db4oPad.Tests.TypeGeneration.Generic`2", result.NameAndNamespace); Assert.AreEqual("Gamlor.Db4oPad.Tests", result.AssemblyName); }
/// <summary> /// Reads a single custom marshal descriptor from the provided input stream. /// </summary> /// <param name="parentModule">The module defining the descriptor.</param> /// <param name="reader">The input stream.</param> /// <returns>The descriptor.</returns> public new static CustomMarshalDescriptor FromReader(ModuleDefinition parentModule, ref BinaryStreamReader reader) { string guid = reader.ReadSerString(); string nativeTypeName = reader.ReadSerString(); string marshalTypeName = reader.ReadSerString(); string cookie = reader.ReadSerString(); return(new CustomMarshalDescriptor(guid, nativeTypeName, marshalTypeName is null ? null : TypeNameParser.Parse(parentModule, marshalTypeName), cookie)); }
public void ParseGenericNested() { var input = string.Format("Namespace.Map`2[{0}, [Namespace.List`1[{0}], {1}]], {1}", GenericArg, AsseblyName); var result = TypeNameParser.ParseString(input); Assert.AreEqual("Namespace.Map`2", result.NameAndNamespace); Assert.AreEqual(AsseblyName, result.AssemblyName); ValidateGenericArgs(result.GenericArguments.Take(1)); ValidateGenericArgs(result.GenericArguments.Last().Value.GenericArguments); }
public void SimpleArrayType() { const string ns = "MyNamespace"; const string name = "MyType"; var elementType = new TypeReference(_module, ns, name).ToTypeSignature(); var expected = new SzArrayTypeSignature(elementType); var actual = TypeNameParser.Parse(_module, $"{ns}.{name}[]"); Assert.Equal(expected, actual, _comparer); }
public void ParsesSingleGenericClass() { var clas = TypeNameParser.Parse("Class<T>"); Assert.AreEqual("Class", clas.Surname); Assert.AreEqual(1, clas.GenericArguments.Count); var t = clas.GenericArguments.Get(0); Assert.AreEqual("T", t.Surname); Assert.False(clas.ContainingType.HasValue); Assert.False(t.ContainingType.HasValue); }
private void EvaluateType(SqlNode node, MetaType metaType) { var sessionFactory = SessionFactoryHelper.Factory; var className = sessionFactory.GetImportedClassName(node.OriginalText); var discriminatorValue = metaType.GetMetaValue( TypeNameParser.Parse(className).Type, sessionFactory.Dialect); node.Text = discriminatorValue; }
public void MultiGenericNested() { var input = string.Format("Namespace.MainClass`1+NestedClass`2[{0}, {0}, {0}], {1}", GenericArg, AsseblyName); var result = TypeNameParser.ParseString(input); Assert.AreEqual("Namespace.MainClass`1+NestedClass`2", result.NameAndNamespace); Assert.AreEqual(AsseblyName, result.AssemblyName); ValidateGenericArgs(result.GenericArguments.Take(1)); ValidateGenericArgs(result.GenericArguments.Skip(1).Take(1)); ValidateGenericArgs(result.GenericArguments.Last().Value.GenericArguments); }
public void MultidimensionalArray() { const string ns = "MyNamespace"; const string name = "MyType"; var elementType = new TypeReference(_module, ns, name).ToTypeSignature(); var expected = new ArrayTypeSignature(elementType, 4); var actual = TypeNameParser.Parse(_module, $"{ns}.{name}[,,,]"); Assert.Equal(expected, actual, _comparer); }
public void TestInvalidTypes() { Assert.Throws <ArgumentException>(() => TypeNameParser.Parse(null)); Assert.Throws <ArgumentException>(() => TypeNameParser.Parse("")); Assert.Throws <IgniteException>(() => TypeNameParser.Parse("x[")); Assert.Throws <IgniteException>(() => TypeNameParser.Parse("x[[]")); Assert.Throws <IgniteException>(() => TypeNameParser.Parse("x`[")); Assert.Throws <IgniteException>(() => TypeNameParser.Parse("x`[ ]")); Assert.Throws <IgniteException>(() => TypeNameParser.Parse("x,")); Assert.Throws <IgniteException>(() => TypeNameParser.Parse("x`2[x")); }
public void NestedTypeNoNamespace(string name, string nestedType) { var expected = new TypeReference( new TypeReference(_module, null, name), null, nestedType) .ToTypeSignature(); var actual = TypeNameParser.Parse(_module, $"{name}+{nestedType}"); Assert.Equal(expected, actual, _comparer); }
public void NH1822() { var typeName = @"OldMutual.SalesGear.Data.ReferenceType`2[ [OldMutual.SalesGear.Reference.Core.Channel, OldMutual.SalesGear.Reference.Core], [OldMutual.SalesGear.Reference.Core.Channels, OldMutual.SalesGear.Reference.Core] ], OldMutual.SalesGear.Data"; var expected = "OldMutual.SalesGear.Data.ReferenceType`2[[OldMutual.SalesGear.Reference.Core.Channel, OldMutual.SalesGear.Reference.Core],[OldMutual.SalesGear.Reference.Core.Channels, OldMutual.SalesGear.Reference.Core]], OldMutual.SalesGear.Data"; var a = TypeNameParser.Parse(typeName); Assert.That(a.ToString(), Is.EqualTo(expected)); }
public void ReadEscapedTypeName() { const string ns = "MyNamespace"; const string escapedName = "MyType\\+WithPlus"; const string name = "MyType+WithPlus"; var expected = new TypeReference(_module, ns, name).ToTypeSignature(); var actual = TypeNameParser.Parse(_module, $"{ns}.{escapedName}"); Assert.Equal(expected, actual, _comparer); }
private string GetTypeName(TypeNameParser name) { if (IsSimpleName) { return(name.GetName()); } var fullName = NamespaceToLower && name.HasNamespace() ? name.GetNamespace().ToLower(CultureInfo.InvariantCulture) + name.GetName() : name.GetNameWithNamespace(); return(NamespacePrefix + fullName); }
public void TypeWithAssemblyName() { const string ns = "MyNamespace"; const string name = "MyType"; var assemblyRef = new AssemblyReference("MyAssembly", new Version(1, 2, 3, 4)); var expected = new TypeReference(assemblyRef, ns, name).ToTypeSignature(); var actual = TypeNameParser.Parse(_module, $"{ns}.{name}, {assemblyRef.FullName}"); Assert.Equal(expected, actual, _comparer); }
public ClassEntry(string extends, string className, string entityName, string assembly, string @namespace) { fullExtends = string.IsNullOrEmpty(extends) ? null : TypeNameParser.Parse(extends, @namespace, assembly); fullClassName = string.IsNullOrEmpty(className) ? null : TypeNameParser.Parse(className, @namespace, assembly); this.entityName = entityName; extendsEntityName = string.IsNullOrEmpty(extends) ? null : extends; unchecked { hashCode = (entityName != null ? entityName.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (fullExtends != null ? fullExtends.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (fullClassName != null ? fullClassName.GetHashCode() : 0); } }
public void ParsesClassInNamespace() { var clas = TypeNameParser.Parse("Ns1.Ns2.Class"); Assert.AreEqual("Class", clas.Surname); var ns2 = clas.ContainingType.Value; Assert.AreEqual("Ns2", ns2.Surname); var ns1 = ns2.ContainingType.Value; Assert.AreEqual("Ns1", ns1.Surname); Assert.False(ns1.ContainingType.HasValue); }
public void SpacesInAssemblySpec() { const string ns = "MyNamespace"; const string name = "MyType"; const string assemblyRef = "Some Assembly"; var scope = new AssemblyReference(assemblyRef, new Version(1, 0, 0, 0)); var expected = new TypeReference(_module, scope, ns, name).ToTypeSignature(); var actual = TypeNameParser.Parse(_module, $"{ns}.{name}, {assemblyRef}, Version={scope.Version}"); Assert.Equal(expected, actual, _comparer); }
public void StringArray() { var input = "System.String[], mscorlib"; var result = TypeNameParser.ParseString(input); Assert.AreEqual("System.String[]", result.NameAndNamespace); Assert.AreEqual("mscorlib", result.AssemblyName); Assert.AreEqual("System.String[], mscorlib", result.FullName); Assert.AreEqual(1, result.OrderOfArray); Assert.AreEqual("System.String, mscorlib", result.ArrayOf.Value.FullName); }
public void GenericTypeSingleBrackets() { const string ns = "MyNamespace"; const string name = "MyType"; var elementType = new TypeReference(_module, ns, name); var argumentType = _module.CorLibTypeFactory.Object; var expected = new GenericInstanceTypeSignature(elementType, false, argumentType); var actual = TypeNameParser.Parse(_module, $"{ns}.{name}[{argumentType.Namespace}.{argumentType.Name}]"); Assert.Equal(expected, actual, _comparer); }
public void ReadTypeInSameAssemblyWithoutScope() { const string ns = "MyNamespace"; const string name = "MyType"; var definition = new TypeDefinition(ns, name, TypeAttributes.Public, _module.CorLibTypeFactory.Object.Type); _module.TopLevelTypes.Add(definition); var expected = definition.ToTypeSignature(); var actual = TypeNameParser.Parse(_module, $"{ns}.{name}"); Assert.Equal(expected, actual, _comparer); }
public void TestCompilerGeneratedTypes([Values( @"Foo.Bar+<Abc-Def<System-String\,System-Byte\[\]>-Convert>d__0", @"Foo.Bar+<Foo-Bar<Abc-Def<System-Byte\[\]>\,Abc-Def<System-String>>-Convert>d__4`1", @"Program\+IFoo`2\[\[System.Int32\, System.Private.CoreLib\, Version=4.0.0.0\, Culture=neutral\, PublicKeyToken=567\]\,\[System.String\, System.Private.CoreLib\, Version=4.0.0.0\, Culture=neutral\, PublicKeyToken=123\]\]" )] string typeName) { var res = TypeNameParser.Parse(typeName); Assert.AreEqual(typeName, res.GetName()); Assert.IsNull(res.GetAssemblyName()); Assert.IsNull(res.GetArray()); Assert.IsFalse(res.HasNamespace()); }
/// <summary> /// Returns a reference to the type that the given alias stands for. For example, if alias is a type forwarder, return a reference to the forwarded type (in another assembly). /// </summary> internal INamedTypeReference/*?*/ GetReferenceToAliasedType(ExportedTypeAliasBase alias) { Assembly/*?*/ thisAssembly = this.Module as Assembly; if (thisAssembly == null) return null; uint exportedTypeRowId = alias.ExportedTypeRowId; if (exportedTypeRowId == 0) return null; ExportedTypeRow exportedTypeRow = this.PEFileReader.ExportedTypeTable[exportedTypeRowId]; uint tokenType = exportedTypeRow.Implementation & TokenTypeIds.TokenTypeMask; uint rowId = exportedTypeRow.Implementation & TokenTypeIds.RIDMask; IName namespaceName = this.GetNameFromOffset(exportedTypeRow.TypeNamespace); IName mangledTypeName = this.GetNameFromOffset(exportedTypeRow.TypeName); IName unmangledTypeName = this.GetUnmangledNameFromOffset(exportedTypeRow.TypeName); switch (tokenType) { case TokenTypeIds.File: { FileReference/*?*/ fileRef = this.GetFileReferenceAt(rowId); if (fileRef == null) return null; var module = thisAssembly.FindMemberModuleNamed(fileRef.Name) as Module; if (module == null) return null; var foundType = module.PEFileToObjectModel.ResolveNamespaceTypeDefinition(namespaceName, mangledTypeName); if (foundType == null) return null; return foundType; } case TokenTypeIds.ExportedType: { ExportedTypeAliasBase/*?*/ parentExportedType = this.GetExportedTypeAtRowWorker(rowId); if (parentExportedType == null) return null; var parentModuleType = this.GetReferenceToAliasedType(parentExportedType); if (parentModuleType == null) return null; ITypeDefinition parentType = parentModuleType.ResolvedType; if (!(parentType is Dummy)) { foreach (ITypeDefinitionMember tdm in parentModuleType.ResolvedType.GetMembersNamed(unmangledTypeName, false)) { var modTypeRef = tdm as IMetadataReaderNamedTypeReference; if (modTypeRef != null) return modTypeRef; } } else { NamespaceTypeNameTypeReference/*?*/ nstr = parentModuleType as NamespaceTypeNameTypeReference; if (nstr != null) { var nestedTypeName = new NestedTypeName(this.NameTable, nstr.NamespaceTypeName, mangledTypeName); return nestedTypeName.GetAsNamedTypeReference(this, nstr.Module); } NestedTypeNameTypeReference/*?*/ netr = parentModuleType as NestedTypeNameTypeReference; if (netr != null) { var nestedTypeName = new NestedTypeName(this.NameTable, netr.NestedTypeName, mangledTypeName); return nestedTypeName.GetAsNamedTypeReference(this, netr.Module); } } return null; } case TokenTypeIds.AssemblyRef: { AssemblyReference/*?*/ assemRef = this.GetAssemblyReferenceAt(rowId); if (assemRef == null) return null; var internalAssembly = assemRef.ResolvedAssembly as Assembly; if (internalAssembly != null) { //Since we have already loaded the assembly that is supposed to hold this type, we may as well try and resolve it. PEFileToObjectModel assemblyPEFileToObjectModel = internalAssembly.PEFileToObjectModel; var type = assemblyPEFileToObjectModel.ResolveNamespaceTypeDefinition(namespaceName, mangledTypeName); if (type != null) return type; //The other assembly (internalAssembly) does not have a namespace type def for this reference. //Perhaps it has an alias that forwards to somewhere else... Not very likely happen in practice, I would hope. ExportedTypeAliasBase/*?*/ aliasType = assemblyPEFileToObjectModel.TryToResolveAsNamespaceTypeAlias(namespaceName, mangledTypeName); if (aliasType != null && aliasType != alias) return assemblyPEFileToObjectModel.GetReferenceToAliasedType(aliasType); //Although we can resolve the target assembly, we can neither resolve the aliased type, nor find a secondary alias. //This is mighty strange. Probably the host has fluffed assembly resolution and internalAssembly isn't really the //assembly we are looking for. We now have to give up and simply return an unresolved reference. } string fullTypeName = mangledTypeName.Value; if (namespaceName.Value.Length > 0) fullTypeName = namespaceName.Value+"."+fullTypeName; var parser = new TypeNameParser(this.NameTable, fullTypeName); return parser.ParseTypeName().GetAsTypeReference(this, assemRef) as INamedTypeReference; } } return null; }
internal ITypeReference/*?*/ GetSerializedTypeNameAsTypeReference( string serializedTypeName ) { TypeNameParser typeNameParser = new TypeNameParser(this.NameTable, serializedTypeName); TypeName/*?*/ typeName = typeNameParser.ParseTypeName(); if (typeName == null) // MDError... return null; return this.GetSerializedTypeNameAsTypeReference(typeName); }
/// <summary> /// Parses the specified typename string as obtained by /// <c>System.Object.GetType().FullName</c> or /// <c>System.Object.GetType().AssemblyQualifiedName</c>. /// </summary> /// <param name="s">The typename string.</param> /// <returns>A <see cref="TypeName"/> representing the type name.</returns> public static TypeName Parse(string s) { TypeNameParser p = new TypeNameParser(s); try { return p.TransformTypeSpec(); } catch (ParseError x) { if (p.Position > 0) throw new ParseError(String.Format( "Could not parse typename: {0}\n\"{1}====>{2}<===={3}", x.Message, s.Substring(0, p.Position), s[p.Position], s.Substring(p.Position, s.Length - p.Position))); else throw new ParseError(String.Format( "Could not parse typenname \"{0}\" at end of input: {1}", s, x.Message)); } }
private void CreateInstance() { Contract.Requires(currentTask != null); Contract.Requires(currentTask.EntryPoint != null); Contract.Requires(!string.IsNullOrEmpty(currentTask.EntryPoint.QualifiedClassName)); using (Perfomance.Trace("GeneralEngine::CreateInstance()").BindToConsole()) { var type = Type.GetType(currentTask.EntryPoint.QualifiedClassName); if (type == null) { var typeName = new TypeNameParser().Parse(currentTask.EntryPoint.QualifiedClassName); type = currentLoadingAssembly.GetType(typeName.Name, false); if (type == null) throw new UnableToLoadTaskException(string.Format( "Unable to load task: entry point class {0} doesn't exists.", currentTask.EntryPoint.QualifiedClassName)); } try { var instance = Activator.CreateInstance(type); taskInstance = instance as ITask; if (taskInstance == null) throw new UnableToLoadTaskException(string.Format( "Unable to load task: entry point class {0} doesn't implement interface {1}.", currentTask.EntryPoint.QualifiedClassName, typeof(ITask).FullName)); } catch (MissingMethodException inner) { throw new UnableToLoadTaskException(string.Format( "Unable to load task: entry point class {0} doesn't have a parameterless contructor.", currentTask.EntryPoint.QualifiedClassName), inner); } catch (TargetInvocationException inner) { throw new UnableToLoadTaskException(string.Format( "Unable to load task: entry point class {0} constructor has thrown an exception.", currentTask.EntryPoint.QualifiedClassName), inner); } } }
/// <summary> /// Finds the given aliased type in the exported type table. /// </summary> /// <param name="aliasAliasBase"></param> /// <returns></returns> internal IModuleTypeReference/*?*/ FindExportedType( ExportedTypeAliasBase aliasAliasBase ) { Assembly/*?*/ thisAssembly = this.Module as Assembly; if (thisAssembly == null) return null; uint exportedTypeRowId = aliasAliasBase.ExportedTypeRowId; if (exportedTypeRowId == 0) return null; ExportedTypeRow exportedTypeRow = this.PEFileReader.ExportedTypeTable[exportedTypeRowId]; uint tokenType = exportedTypeRow.Implementation & TokenTypeIds.TokenTypeMask; uint rowId = exportedTypeRow.Implementation & TokenTypeIds.RIDMask; IName namespaceName = this.GetNameFromOffset(exportedTypeRow.TypeNamespace); IName typeName = this.GetNameFromOffset(exportedTypeRow.TypeName); switch (tokenType) { case TokenTypeIds.File: { FileReference/*?*/ fileRef = this.GetFileReferenceAt(rowId); if (fileRef == null) { return null; } Module/*?*/ module =thisAssembly.FindMemberModuleNamed(fileRef.Name); if (module == null) { return null; } TypeBase/*?*/ foundType = module.PEFileToObjectModel.ResolveNamespaceTypeDefinition(namespaceName, typeName); if (foundType == null) { return null; } return foundType; } case TokenTypeIds.ExportedType: { ExportedTypeAliasBase/*?*/ parentExportedType = this.GetExportedTypeAtRowWorker(rowId); if (parentExportedType == null) { return null; } IModuleTypeReference/*?*/ parentModuleType = this.FindExportedType(parentExportedType); if (parentModuleType == null) { return null; } ITypeDefinition parentType = parentModuleType.ResolvedType; if (parentType != Dummy.Type) { foreach (ITypeDefinitionMember tdm in parentModuleType.ResolvedType.GetMembersNamed(typeName, false)) { IModuleTypeReference/*?*/ modTypeRef = tdm as IModuleTypeReference; if (modTypeRef != null) return modTypeRef; } } else { NamespaceTypeNameTypeReference/*?*/ nstr = parentModuleType as NamespaceTypeNameTypeReference; if (nstr != null) { var nestedTypeName = new NestedTypeName(this.NameTable, nstr.NamespaceTypeName, typeName); return nestedTypeName.GetAsTypeReference(this, nstr.Module); } NestedTypeNameTypeReference/*?*/ netr = parentModuleType as NestedTypeNameTypeReference; if (netr != null) { var nestedTypeName = new NestedTypeName(this.NameTable, netr.NestedTypeName, typeName); return nestedTypeName.GetAsTypeReference(this, netr.Module); } } return null; } case TokenTypeIds.AssemblyRef: { AssemblyReference/*?*/ assemRef = this.GetAssemblyReferenceAt(rowId); if (assemRef == null) { return null; } var internalAssembly = assemRef.ResolvedAssembly as Assembly; if (internalAssembly != null) { PEFileToObjectModel assemblyPEFileToObjectModel = internalAssembly.PEFileToObjectModel; TypeBase/*?*/ type = assemblyPEFileToObjectModel.ResolveNamespaceTypeDefinition(namespaceName, typeName); if (type != null) return type; ExportedTypeAliasBase/*?*/ aliasType = assemblyPEFileToObjectModel.ResolveExportedNamespaceType(namespaceName, typeName); if (aliasType != null && aliasType != aliasAliasBase) { return assemblyPEFileToObjectModel.FindExportedType(aliasType); } } else { string fullTypeName = typeName.Value; if (namespaceName.Value.Length > 0) fullTypeName = namespaceName.Value+"."+typeName.Value; var parser = new TypeNameParser(this.NameTable, fullTypeName); return parser.ParseTypeName().GetAsTypeReference(this, assemRef); } } break; } return null; }
private bool ParseTypeArgumentsOptional(ref int arity) { bool flag2; this.SkipWhites(); if (this.IsEOL) { return true; } if (!this.CurrentIs('[')) { return true; } if ((this.NextWillBe(']', true) || this.NextWillBe(',', true)) || this.NextWillBe('*', true)) { return true; } if (!this.Next(true)) { return false; } this._info.TypeArguments.Capacity = arity; Label_0083: flag2 = false; if (this.CurrentIs('[')) { flag2 = true; if (!this.Next(true)) { return false; } } TypeNameParseInfo info = new TypeNameParseInfo(); TypeNameParser parser = new TypeNameParser(this._data, this._p, this._end, info, true); if (!parser.Parse(flag2)) { return false; } this._p = parser._p; this._info.TypeArguments.Add(info); this.SkipWhites(); if (this.IsEOL) { return false; } if (flag2) { if (!this.CurrentIs(']')) { return false; } if (!this.Next(true)) { return false; } } if (!this.CurrentIs(']')) { if (!this.CurrentIs(',')) { return false; } if (!this.Next(true)) { return false; } goto Label_0083; } if (this._info.TypeArguments.Count != arity) { return false; } this.Next(true); return true; }
public static TypeNameParseInfo Parse(string name) { TypeNameParseInfo info = new TypeNameParseInfo(); char[] data = name.ToCharArray(); TypeNameParser parser = new TypeNameParser(data, 0, data.Length, info, false); return (parser.Parse(true) ? info : null); }
private ITypeElement HighlightUndefinedType(IXmlTag tag, string attributeName) { IXmlAttribute attribute = tag.GetAttribute(attributeName); if ((attribute == null) || (attribute.XmlName != attributeName) || (attribute.UnquotedValue == null)) { return null; } string fullQualifiedTypeName = attribute.UnquotedValue; Logger.LogMessage("Type is {0}", fullQualifiedTypeName); Parser parser = new Parser(); IParserError error; parser.Parse(fullQualifiedTypeName, out error); if (error != ParserError.None) { AddHighlighting(attribute, new TypeHighlighting(string.Format("Error in type: {0}", error.Message))); } ITypeElement typeElement = PsiUtils.GetTypeElement(tag, m_Process.Solution, fullQualifiedTypeName); if ((typeElement == null) || (typeElement.Module == null)) { AddHighlighting(attribute, new TypeHighlighting(string.Format("Type '{0}' could not be resolved", fullQualifiedTypeName))); } else { // TODO: put TypeNameParser into Parser and refactor this TypeNameParser typeNameParser = new TypeNameParser(fullQualifiedTypeName, m_Assembly, m_Namespace); string assemblyName = typeNameParser.AssemblyName; if (typeElement.Module.Name != "mscorlib") { BuildSettingsManager buildSettingsManager = BuildSettingsManager.GetInstance(typeElement.GetProjectFiles()[0].GetProject()); if (buildSettingsManager != null) { IAssemblyFile outputAssemblyFile = buildSettingsManager.GetOutputAssemblyFile(); if ((outputAssemblyFile != null) && (outputAssemblyFile.Name != assemblyName)) { AddHighlighting(attribute, new TypeHighlighting(string.Format("Assembly name '{0}' should be '{1}'", assemblyName, outputAssemblyFile.Name))); } } } } return typeElement; }