/// <summary> /// Creates a new unknown type. /// </summary> /// <param name="namespaceName">Namespace name, if known. Can be null if unknown.</param> /// <param name="name">Name of the type, must not be null.</param> /// <param name="typeParameterCount">Type parameter count, zero if unknown.</param> public UnknownType(string namespaceName, string name, int typeParameterCount = 0) { if (name == null) throw new ArgumentNullException("name"); this.namespaceKnown = namespaceName != null; this.fullTypeName = new TopLevelTypeName(namespaceName ?? string.Empty, name, typeParameterCount); }
public NUnitTestMethod(ITestProject parentProject, IUnresolvedMethod method, FullTypeName derivedFixture = default(FullTypeName)) { if (parentProject == null) throw new ArgumentNullException("parentProject"); this.parentProject = parentProject; UpdateTestMethod(method, derivedFixture); }
public NUnitTestClass(NUnitTestProject parentProject, FullTypeName fullTypeName) { if (parentProject == null) throw new ArgumentNullException("parentProject"); this.parentProject = parentProject; this.fullTypeName = fullTypeName; BindResultToCompositeResultOfNestedTests(); // No need to call UpdateTestClass() here as NestedTestsInitialized still is false }
IType GetMethodReturnType(string typeName) { var fullTypeName = new FullTypeName(typeName); IType type = typeDefinition.Compilation.FindType(fullTypeName); if (type != null) { return type; } return new UnknownType(fullTypeName); }
IType GetFieldType(string type) { var fieldTypeName = new FullTypeName(type); IType fieldType = typeDefinition.Compilation.FindType(fieldTypeName); if (fieldType != null) { return fieldType; } return new UnknownType(fieldTypeName); }
/// <summary> /// Retrieves the specified type in this compilation. /// Returns an <see cref="UnknownType"/> if the type cannot be found in this compilation. /// </summary> /// <remarks> /// There can be multiple types with the same full name in a compilation, as a /// full type name is only unique per assembly. /// If there are multiple possible matches, this method will return just one of them. /// When possible, use <see cref="IAssembly.GetTypeDefinition"/> instead to /// retrieve a type from a specific assembly. /// </remarks> public static IType FindType(this ICompilation compilation, FullTypeName fullTypeName) { if (compilation == null) throw new ArgumentNullException("compilation"); foreach (IAssembly asm in compilation.Assemblies) { ITypeDefinition def = asm.GetTypeDefinition(fullTypeName); if (def != null) return def; } return new UnknownType(fullTypeName); }
/// <summary> /// Creates a new unknown type. /// </summary> /// <param name="fullTypeName">Full name of the unknown type.</param> public UnknownType(FullTypeName fullTypeName) { if (fullTypeName.Name == null) { Debug.Assert(fullTypeName == default(FullTypeName)); this.namespaceKnown = false; this.fullTypeName = new TopLevelTypeName(string.Empty, "?", 0); } else { this.namespaceKnown = true; this.fullTypeName = fullTypeName; } }
public virtual global::EnvDTE.CodeVariable AddVariable(string name, object type, object Position = null, global::EnvDTE.vsCMAccess Access = global::EnvDTE.vsCMAccess.vsCMAccessPublic, object Location = null) { var fieldTypeName = new FullTypeName((string)type); var td = typeModel.Resolve(); if (td == null) return null; IType fieldType = td.Compilation.FindType(fieldTypeName); context.CodeGenerator.AddField(td, Access.ToAccessibility(), fieldType, name); var fieldModel = typeModel.Members.OfType<IFieldModel>().FirstOrDefault(f => f.Name == name); if (fieldModel != null) { return new CodeVariable(context, fieldModel); } return null; }
public void UpdateTestMethod(IUnresolvedMethod method, FullTypeName derivedFixture = default(FullTypeName)) { if (method == null) throw new ArgumentNullException("method"); string oldDisplayName = this.displayName; this.derivedFixture = derivedFixture; this.method = method; if (this.IsInherited) displayName = method.DeclaringTypeDefinition.Name + "." + method.Name; else displayName = method.Name; if (displayName != oldDisplayName && DisplayNameChanged != null) DisplayNameChanged(this, EventArgs.Empty); }
public MSTestClass(MSTestProject parentProject, FullTypeName fullTypeName) { this.parentProject = parentProject; this.fullTypeName = fullTypeName; BindResultToCompositeResultOfNestedTests(); }
/// <summary> /// Creates a new GetClassTypeReference that searches a top-level type in the specified assembly. /// </summary> /// <param name="assembly">A reference to the assembly containing this type. /// If this parameter is null, the GetClassTypeReference will search in all assemblies belonging to the ICompilation.</param> /// <param name="namespaceName">The namespace name containing the type, e.g. "System.Collections.Generic".</param> /// <param name="name">The name of the type, e.g. "List".</param> /// <param name="typeParameterCount">The number of type parameters, (e.g. 1 for List<T>).</param> public GetClassTypeReference(IAssemblyReference assembly, string namespaceName, string name, int typeParameterCount = 0) { this.assembly = assembly; this.fullTypeName = new TopLevelTypeName(namespaceName, name, typeParameterCount); }
/// <summary> /// Creates a new GetClassTypeReference that searches a top-level type in the specified assembly. /// </summary> /// <param name="module">A reference to the assembly containing this type. /// If this parameter is null, the GetClassTypeReference will search in all assemblies belonging to the ICompilation.</param> /// <param name="namespaceName">The namespace name containing the type, e.g. "System.Collections.Generic".</param> /// <param name="name">The name of the type, e.g. "List".</param> /// <param name="typeParameterCount">The number of type parameters, (e.g. 1 for List<T>).</param> public GetClassTypeReference(IModuleReference module, string namespaceName, string name, int typeParameterCount = 0, bool?isReferenceType = null) { this.module = module; this.fullTypeName = new TopLevelTypeName(namespaceName, name, typeParameterCount); this.isReferenceType = isReferenceType; }
/// <summary> /// Gets the type definition for the specified unresolved type. /// Returns null if the unresolved type does not belong to this assembly. /// </summary> public static ITypeDefinition GetTypeDefinition(this IAssembly assembly, FullTypeName fullTypeName) { if (assembly == null) throw new ArgumentNullException("assembly"); TopLevelTypeName topLevelTypeName = fullTypeName.TopLevelTypeName; ITypeDefinition typeDef = assembly.GetTypeDefinition(topLevelTypeName); if (typeDef == null) return null; int typeParameterCount = topLevelTypeName.TypeParameterCount; for (int i = 0; i < fullTypeName.NestingLevel; i++) { string name = fullTypeName.GetNestedTypeName(i); typeParameterCount += fullTypeName.GetNestedTypeAdditionalTypeParameterCount(i); typeDef = FindNestedType(typeDef, name, typeParameterCount); if (typeDef == null) break; } return typeDef; }
/// <summary> /// Gets the attribute of the specified attribute type (or derived attribute types). /// </summary> /// <param name="entity">The entity on which the attributes are declared.</param> /// <param name="attributeType">The attribute type to look for.</param> /// <param name="inherit"> /// Specifies whether attributes inherited from base classes and base members (if the given <paramref name="entity"/> in an <c>override</c>) /// should be returned. The default is <c>true</c>. /// </param> /// <returns> /// Returns the attribute that was found; or <c>null</c> if none was found. /// If inherit is true, an from the entity itself will be returned if possible; /// and the base entity will only be searched if none exists. /// </returns> public static IAttribute GetAttribute(this IEntity entity, FullTypeName attributeType, bool inherit = true) { return GetAttributes(entity, attributeType, inherit).FirstOrDefault(); }
public void RegisterInheritedClass(FullTypeName baseClassName, NUnitTestClass inheritedClass) { inheritedTestClasses.Add(baseClassName.TopLevelTypeName, inheritedClass); }
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); } } else if (td.IsDelegate(metadata)) { this.Kind = TypeKind.Delegate; } else { this.Kind = TypeKind.Class; this.HasExtensionMethods = this.IsStatic && td.GetCustomAttributes().HasKnownAttribute(metadata, KnownAttribute.Extension); } }
public MSpecTestClass(MSpecTestProject parentProject, FullTypeName fullTypeName) { this.parentProject = parentProject; this.fullTypeName = fullTypeName; BindResultToCompositeResultOfNestedTests(); }
public void UpdateTestClass(ITypeDefinition typeDefinition) { fullTypeName = typeDefinition.FullTypeName; if (this.NestedTestsInitialized) { int baseClassIndex = 0; foreach (IType baseType in typeDefinition.GetNonInterfaceBaseTypes()) { ITypeDefinition baseTypeDef = baseType.GetDefinition(); // Check that the base type isn't equal to System.Object or the current class itself if (baseTypeDef == null || baseTypeDef == typeDefinition || baseTypeDef.KnownTypeCode == KnownTypeCode.Object) { continue; } if (baseTypeDef.DeclaringTypeDefinition != null) { continue; // we only support inheriting from top-level classes } var baseClassName = baseTypeDef.FullTypeName; if (baseClassIndex < baseClassNames.Count && baseClassName == baseClassNames[baseClassIndex]) { // base class is already in the list, just keep it baseClassIndex++; } else { // base class is not in the list, or the remaining portion of the list differs // remove remaining portion of the list: RemoveBaseClasses(baseClassIndex); // Add new base class: parentProject.RegisterInheritedClass(baseClassName, this); baseClassNames.Add(baseClassName); baseClassIndex++; } } HashSet <ITest> newOrUpdatedNestedTests = new HashSet <ITest>(); // Update nested test classes: foreach (ITypeDefinition nestedClass in typeDefinition.NestedTypes) { if (!NUnitTestFramework.IsTestClass(nestedClass)) { continue; } NUnitTestClass nestedTestClass = FindNestedTestClass(nestedClass.Name, nestedClass.TypeParameterCount); if (nestedTestClass != null) { nestedTestClass.UpdateTestClass(nestedClass); } else { nestedTestClass = new NUnitTestClass(parentProject, nestedClass.FullTypeName); this.NestedTestCollection.Add(nestedTestClass); } newOrUpdatedNestedTests.Add(nestedTestClass); } // Get methods (not operators etc.) foreach (IMethod method in typeDefinition.GetMethods(m => m.SymbolKind == SymbolKind.Method)) { if (!NUnitTestFramework.IsTestMethod(method)) { continue; } IUnresolvedMethod unresolvedMethod = (IUnresolvedMethod)method.UnresolvedMember; string methodNameWithDeclaringType; FullTypeName derivedFixture; if (method.DeclaringTypeDefinition == typeDefinition) { derivedFixture = default(FullTypeName); // method is not inherited methodNameWithDeclaringType = method.Name; } else { if (method.DeclaringTypeDefinition == null) { continue; } derivedFixture = fullTypeName; // method is inherited methodNameWithDeclaringType = method.DeclaringTypeDefinition.Name + "." + method.Name; } NUnitTestMethod testMethod; if (method.IsOverride) { testMethod = FindTestMethodWithShortName(method.Name); } else { testMethod = FindTestMethod(methodNameWithDeclaringType); } if (testMethod != null) { testMethod.UpdateTestMethod(unresolvedMethod, derivedFixture); } else { testMethod = new NUnitTestMethod(parentProject, unresolvedMethod, derivedFixture); this.NestedTestCollection.Add(testMethod); } newOrUpdatedNestedTests.Add(testMethod); } // Remove all tests that weren't contained in the new type definition anymore: this.NestedTestCollection.RemoveAll(t => !newOrUpdatedNestedTests.Contains(t)); } }
void CopyGen(TypeDefinition type) { bool isNested = type.IsNested; HashSet <string> IgnoreNestType = new HashSet <string>(); if (!(isNested && IsCopyOrign(genType.DeclaringType))) { var tName = type.FullName.Replace("/", "+"); var name = new FullTypeName(tName); SyntaxTree syntaxTree; if (isNested) { ITypeDefinition typeInfo = Binder.Decompiler.TypeSystem.MainModule.Compilation.FindType(name).GetDefinition(); var tokenOfFirstMethod = typeInfo.MetadataToken; syntaxTree = Binder.Decompiler.Decompile(tokenOfFirstMethod); } else { syntaxTree = Binder.Decompiler.DecompileType(name); } StringWriter w = new StringWriter(); CustomOutputVisitor outVisitor; outVisitor = new BlittableOutputVisitor(isNested, w, Binder.DecompilerSetting.CSharpFormattingOptions); syntaxTree.AcceptVisitor(outVisitor); if (!isNested) { RefNameSpace.UnionWith(outVisitor.nestedUsing); foreach (var ns in RefNameSpace) { if (!string.IsNullOrEmpty(ns)) { CS.Writer.WriteHead($"using {ns}"); } } } var txt = w.ToString(); CS.Writer.WriteLine(txt, false); } if (genType.IsStruct()) { foreach (var f in genType.Fields) { var fType = f.FieldType.Resolve(); if (fType != null && !fType.IsPublic && !fType.IsNested) { Binder.AddType(fType); } } if (!string.IsNullOrEmpty(genType.Namespace)) { CS.Writer.Start($"namespace {genType.Namespace}"); } var classDefine = $"public partial struct {genType.Name}"; CS.Writer.Start(classDefine); GenNested(); foreach (var p in properties) { p.Gen(); } foreach (var m in methods) { m.Gen(); } } }
public void UpdateTestClass(ITypeDefinition typeDefinition) { fullTypeName = typeDefinition.FullTypeName; if (this.NestedTestsInitialized) { int baseClassIndex = 0; foreach (IType baseType in typeDefinition.GetNonInterfaceBaseTypes()) { ITypeDefinition baseTypeDef = baseType.GetDefinition(); // Check that the base type isn't equal to System.Object or the current class itself if (baseTypeDef == null || baseTypeDef == typeDefinition || baseTypeDef.KnownTypeCode == KnownTypeCode.Object) continue; if (baseTypeDef.DeclaringTypeDefinition != null) continue; // we only support inheriting from top-level classes var baseClassName = baseTypeDef.FullTypeName; if (baseClassIndex < baseClassNames.Count && baseClassName == baseClassNames[baseClassIndex]) { // base class is already in the list, just keep it baseClassIndex++; } else { // base class is not in the list, or the remaining portion of the list differs // remove remaining portion of the list: RemoveBaseClasses(baseClassIndex); // Add new base class: parentProject.RegisterInheritedClass(baseClassName, this); baseClassNames.Add(baseClassName); baseClassIndex++; } } HashSet<ITest> newOrUpdatedNestedTests = new HashSet<ITest>(); // Update nested test classes: foreach (ITypeDefinition nestedClass in typeDefinition.NestedTypes) { if (!NUnitTestFramework.IsTestClass(nestedClass)) continue; NUnitTestClass nestedTestClass = FindNestedTestClass(nestedClass.Name, nestedClass.TypeParameterCount); if (nestedTestClass != null) { nestedTestClass.UpdateTestClass(nestedClass); } else { nestedTestClass = new NUnitTestClass(parentProject, nestedClass.FullTypeName); this.NestedTestCollection.Add(nestedTestClass); } newOrUpdatedNestedTests.Add(nestedTestClass); } // Get methods (not operators etc.) foreach (IMethod method in typeDefinition.GetMethods(m => m.SymbolKind == SymbolKind.Method)) { if (!NUnitTestFramework.IsTestMethod(method)) continue; IUnresolvedMethod unresolvedMethod = (IUnresolvedMethod)method.UnresolvedMember; string methodNameWithDeclaringType; FullTypeName derivedFixture; if (method.DeclaringTypeDefinition == typeDefinition) { derivedFixture = default(FullTypeName); // method is not inherited methodNameWithDeclaringType = method.Name; } else { if (method.DeclaringTypeDefinition == null) continue; derivedFixture = fullTypeName; // method is inherited methodNameWithDeclaringType = method.DeclaringTypeDefinition.Name + "." + method.Name; } NUnitTestMethod testMethod; if (method.IsOverride) { testMethod = FindTestMethodWithShortName(method.Name); } else { testMethod = FindTestMethod(methodNameWithDeclaringType); } if (testMethod != null) { testMethod.UpdateTestMethod(unresolvedMethod, derivedFixture); } else { testMethod = new NUnitTestMethod(parentProject, unresolvedMethod, derivedFixture); this.NestedTestCollection.Add(testMethod); } newOrUpdatedNestedTests.Add(testMethod); } // Remove all tests that weren't contained in the new type definition anymore: this.NestedTestCollection.RemoveAll(t => !newOrUpdatedNestedTests.Contains(t)); } }
/// <summary> /// Creates a new GetClassTypeReference that searches a type definition. /// </summary> /// <param name="fullTypeName">The full name of the type.</param> /// <param name="assembly">A reference to the assembly containing this type. /// If this parameter is null, the GetClassTypeReference will search in all /// assemblies belonging to the compilation. /// </param> public GetClassTypeReference(FullTypeName fullTypeName, IAssemblyReference assembly = null) { this.fullTypeName = fullTypeName; this.assembly = assembly; }
/// <summary> /// Looks for the specified type in all the projects in the open solution /// excluding the current project. /// </summary> static IProject FindProjectContainingType(FullTypeName type) { IProject currentProject = SD.ProjectService.CurrentProject; if (currentProject == null) return null; foreach (IProject project in SD.ProjectService.CurrentSolution.Projects.Where(p => p != currentProject)) { if (project.ProjectContent.TopLevelTypeDefinitions.Any(t => t.FullTypeName == type)) { SD.Log.Debug("Found project containing type: " + project.FileName); return project; } } return null; }
public AstType ConvertType(FullTypeName fullTypeName) { if (resolver != null) { foreach (var asm in resolver.Compilation.Assemblies) { var def = asm.GetTypeDefinition(fullTypeName); if (def != null) { return ConvertType(def); } } } TopLevelTypeName top = fullTypeName.TopLevelTypeName; AstType type; if (string.IsNullOrEmpty(top.Namespace)) { type = new SimpleType(top.Name); } else { type = new SimpleType(top.Namespace).MemberType(top.Name); } for (int i = 0; i < fullTypeName.NestingLevel; i++) { type = type.MemberType(fullTypeName.GetNestedTypeName(i)); } return type; }
MSpecTestClass GetMSpecTestClass(FullTypeName fullTypeName) { return(GetTestClass(fullTypeName.TopLevelTypeName) as MSpecTestClass); }
static void SelectedToolUsedHandler(object sender, EventArgs e) { SD.Log.Debug("SelectedToolUsedHandler"); SideTab tab = sideBar.ActiveTab; // try to add project reference if (sender is ICSharpCode.FormsDesigner.Services.ToolboxService) { ToolboxItem selectedItem = ((IToolboxService)sender).GetSelectedToolboxItem(); if (tab is CustomComponentsSideTab) { if (selectedItem != null && selectedItem.TypeName != null) { SD.Log.Debug("Checking for reference to CustomComponent: " + selectedItem.TypeName); // Check current project has the custom component first. ICompilation currentCompilation = GetCompilationForCurrentProject(); var typeName = new FullTypeName(selectedItem.TypeName); if (currentCompilation != null && currentCompilation.FindType(typeName).Kind == TypeKind.Unknown) { // Check other projects in the solution. SD.Log.Debug("Checking other projects in the solution."); IProject projectContainingType = FindProjectContainingType(typeName); if (projectContainingType != null) { AddProjectReferenceToProject(SD.ProjectService.CurrentProject, projectContainingType); } } } } else { if (selectedItem != null && selectedItem.AssemblyName != null) { IProject currentProject = ProjectService.CurrentProject; if (currentProject != null) { if (!ProjectContainsReference(currentProject, selectedItem.AssemblyName)) { AddReferenceToProject(currentProject, selectedItem.AssemblyName); } } } } } if (tab.Items.Count > 0) { tab.ChosenItem = tab.Items[0]; } sideBar.Refresh(); }
protected IType FindType(string type) { var fieldTypeName = new FullTypeName(type); return typeDefinition.Compilation.FindType(fieldTypeName); }
public NUnitTestClass GetTestClass(FullTypeName fullTypeName) { var testClass = (NUnitTestClass)base.GetTestClass(fullTypeName.TopLevelTypeName); int tpc = fullTypeName.TopLevelTypeName.TypeParameterCount; for (int i = 0; i < fullTypeName.NestingLevel; i++) { if (testClass == null) break; tpc += fullTypeName.GetNestedTypeAdditionalTypeParameterCount(i); testClass = testClass.FindNestedTestClass(fullTypeName.GetNestedTypeName(i), tpc); } return testClass; }
public override object Visit (TypeExpression typeExpression) { var result = new FullTypeName (); if (typeExpression.Type != null) { result.AddChild (new Identifier (typeExpression.Type.Name, Convert (typeExpression.Location))); } // if (!string.IsNullOrEmpty (typeExpression.)) { // result.AddChild (new Identifier (typeExpression.Namespace + "." + typeExpression.Name, Convert (typeExpression.Location))); // } else { // result.AddChild (new Identifier (typeExpression.Name, Convert (typeExpression.Location))); // } return result; }
public void RemoveInheritedClass(FullTypeName baseClassName, NUnitTestClass inheritedClass) { inheritedTestClasses.Remove(baseClassName.TopLevelTypeName, inheritedClass); }
private async Task <Document> DecompileSymbolAsync(Document temporaryDocument, ISymbol symbol, CancellationToken cancellationToken) { // Get the name of the type the symbol is in var containingOrThis = symbol.GetContainingTypeOrThis(); var fullName = GetFullReflectionName(containingOrThis); var compilation = await temporaryDocument.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false); string assemblyLocation = null; var isReferenceAssembly = symbol.ContainingAssembly.GetAttributes().Any(attribute => attribute.AttributeClass.Name == nameof(ReferenceAssemblyAttribute) && attribute.AttributeClass.ToNameDisplayString() == typeof(ReferenceAssemblyAttribute).FullName); if (isReferenceAssembly) { try { var fullAssemblyName = symbol.ContainingAssembly.Identity.GetDisplayName(); GlobalAssemblyCache.Instance.ResolvePartialName(fullAssemblyName, out assemblyLocation, preferredCulture: CultureInfo.CurrentCulture); } catch (Exception e) when(FatalError.ReportWithoutCrash(e)) { } } if (assemblyLocation == null) { var reference = compilation.GetMetadataReference(symbol.ContainingAssembly); assemblyLocation = (reference as PortableExecutableReference)?.FilePath; if (assemblyLocation == null) { throw new NotSupportedException(EditorFeaturesResources.Cannot_navigate_to_the_symbol_under_the_caret); } } // Load the assembly. var assemblyDefinition = AssemblyDefinition.ReadAssembly(assemblyLocation, new ReaderParameters() { AssemblyResolver = new RoslynAssemblyResolver(compilation) }); // Initialize a decompiler with default settings. var decompiler = new CSharpDecompiler(assemblyDefinition.MainModule, new DecompilerSettings()); // Escape invalid identifiers to prevent Roslyn from failing to parse the generated code. // (This happens for example, when there is compiler-generated code that is not yet recognized/transformed by the decompiler.) decompiler.AstTransforms.Add(new EscapeInvalidIdentifiers()); var fullTypeName = new FullTypeName(fullName); var decompilerVersion = FileVersionInfo.GetVersionInfo(typeof(CSharpDecompiler).Assembly.Location); // Add header to match output of metadata-only view. // (This also makes debugging easier, because you can see which assembly was decompiled inside VS.) var header = $"#region {FeaturesResources.Assembly} {assemblyDefinition.FullName}" + Environment.NewLine + $"// {assemblyDefinition.MainModule.FileName}" + Environment.NewLine + $"// Decompiled with ICSharpCode.Decompiler {decompilerVersion.FileVersion}" + Environment.NewLine + "#endregion" + Environment.NewLine; // Try to decompile; if an exception is thrown the caller will handle it var text = decompiler.DecompileTypeAsString(fullTypeName); return(temporaryDocument.WithText(SourceText.From(header + text))); }
/// <summary> /// Gets the attributes of the specified attribute type (or derived attribute types). /// </summary> /// <param name="entity">The entity on which the attributes are declared.</param> /// <param name="attributeType">The attribute type to look for.</param> /// <param name="inherit"> /// Specifies whether attributes inherited from base classes and base members (if the given <paramref name="entity"/> in an <c>override</c>) /// should be returned. The default is <c>true</c>. /// </param> /// <returns> /// Returns the list of attributes that were found. /// If inherit is true, attributes from the entity itself are returned first; followed by attributes inherited from the base entity. /// </returns> public static IEnumerable<IAttribute> GetAttributes(this IEntity entity, FullTypeName attributeType, bool inherit = true) { if (entity == null) throw new ArgumentNullException("entity"); return GetAttributes(entity, attrType => { ITypeDefinition typeDef = attrType.GetDefinition(); return typeDef != null && typeDef.FullTypeName == attributeType; }, inherit); }
MSTestClass GetMSTestClass(FullTypeName fullTypeName) { return GetTestClass(fullTypeName.TopLevelTypeName) as MSTestClass; }
/// <summary> /// Creates a new GetClassTypeReference that searches a type definition. /// </summary> /// <param name="fullTypeName">The full name of the type.</param> /// <param name="module">A reference to the module containing this type. /// If this parameter is null, the GetClassTypeReference will search in all /// assemblies belonging to the compilation. /// </param> public GetClassTypeReference(FullTypeName fullTypeName, IModuleReference module = null, bool?isReferenceType = null) { this.fullTypeName = fullTypeName; this.module = module; this.isReferenceType = isReferenceType; }
public override object Visit (SimpleName simpleName) { var result = new FullTypeName (); result.AddChild (new Identifier (simpleName.Name, Convert (simpleName.Location)), FullTypeName.Roles.Identifier); if (simpleName.TypeArguments != null) { var location = LocationsBag.GetLocations (simpleName); if (location != null) result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), FullTypeName.Roles.LChevron); // AddTypeArguments (result, location, simpleName.TypeArguments); if (location != null && location.Count > 1) result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), FullTypeName.Roles.RChevron); } return result; }
/// <summary> /// Updates the parse information. /// </summary> public void Update(IList <IUnresolvedTypeDefinition> oldFile, IList <IUnresolvedTypeDefinition> newFile) { List <ITypeDefinitionModel> oldModels = null; List <ITypeDefinitionModel> newModels = null; bool[] oldTypeDefHandled = null; if (oldFile.Count > 0) { oldTypeDefHandled = new bool[oldFile.Count]; } foreach (var newPart in newFile) { FullTypeName newFullTypeName = newPart.FullTypeName; TypeDefinitionModel model; if (dict.TryGetValue(newFullTypeName.TopLevelTypeName, out model)) { // Existing type changed // Find a matching old part: IUnresolvedTypeDefinition oldPart = null; if (oldTypeDefHandled != null) { for (int i = 0; i < oldTypeDefHandled.Length; i++) { if (oldTypeDefHandled[i]) { continue; } if (oldFile[i].FullTypeName == newFullTypeName) { oldTypeDefHandled[i] = true; oldPart = oldFile[i]; break; } } } model.Update(oldPart, newPart); } else { // New type added model = new TypeDefinitionModel(context, newPart); dict.Add(newFullTypeName.TopLevelTypeName, model); if (newModels == null) { newModels = new List <ITypeDefinitionModel>(); } newModels.Add(model); } } // Remove all old parts that weren't updated: if (oldTypeDefHandled != null) { for (int i = 0; i < oldTypeDefHandled.Length; i++) { if (!oldTypeDefHandled[i]) { IUnresolvedTypeDefinition oldPart = oldFile[i]; TopLevelTypeName topLevelTypeName = oldPart.FullTypeName.TopLevelTypeName; TypeDefinitionModel model; if (dict.TryGetValue(topLevelTypeName, out model)) { // Remove the part from the model if (model.Parts.Count > 1) { model.Update(oldPart, null); } else { dict.Remove(topLevelTypeName); if (oldModels == null) { oldModels = new List <ITypeDefinitionModel>(); } oldModels.Add(model); } } } } } // Raise the event if necessary: if (collectionChangedEvent.ContainsHandlers && (oldModels != null || newModels != null)) { IReadOnlyCollection <ITypeDefinitionModel> emptyList = EmptyList <ITypeDefinitionModel> .Instance; collectionChangedEvent.Fire(oldModels ?? emptyList, newModels ?? emptyList); } }