public void TestCollectFiles() { var code1 = @" namespace project1 { class A { private void Method1() { } public void Method2() { } } public class B { } }"; var project1 = new UnknownProject { FileName = "projectc1.csproj" }; var project2 = new DotNetAssemblyProject { FileName = "projectc2.csproj" }; project2.References.Add(new MonoDevelop.Projects.ProjectReference(project1)); var solution = new Solution(); solution.RootFolder.AddItem(project1); solution.RootFolder.AddItem(project2); solution.RootFolder.AddItem(new UnknownProject { FileName = "dummy.csproj" }); project1.AddFile(new ProjectFile("dummy.cs")); TypeSystemService.LoadProject(project1); TypeSystemService.ParseFile(project1, "test.cs", "text/x-csharp", code1); var compilation = TypeSystemService.GetCompilation(project1); var typeA = compilation.MainAssembly.GetTypeDefinition("project1", "A", 0); TestCollectFiles(project1, typeA.GetMembers(m => m.Name == "Method1"), new [] { CreateTestTuple(project1, new [] { (FilePath)"test.cs" }) }); TestCollectFiles(project1, new [] { typeA }, new [] { CreateTestTuple(project1) }); TestCollectFiles(project1, typeA.GetMembers(m => m.Name == "Method2"), new [] { CreateTestTuple(project1) }); TestCollectFiles(project1, typeA.GetMembers(), new [] { CreateTestTuple(project1) }); TestCollectFiles(solution, typeA.GetMembers(m => m.Name == "Method1"), new [] { CreateTestTuple(project1, new [] { (FilePath)"test.cs" }) }); TestCollectFiles(solution, typeA.GetMembers(), new [] { CreateTestTuple(project1) }); var typeB = compilation.MainAssembly.GetTypeDefinition("project1", "B", 0); TestCollectFiles(solution, new [] { typeB }, new [] { CreateTestTuple(project1), CreateTestTuple(project2) }); TestCollectFiles(solution, new [] { typeA, typeB }, new [] { CreateTestTuple(project1), CreateTestTuple(project2) }); }
public void TestCollectProjects() { var code = @" namespace project1 { class A { private void Method1() { } public void Method2() { } } public class B { private void Method1() { } protected void Method2() { } } }"; var project1 = new UnknownProject { FileName = "project1.csproj" }; var project2 = new DotNetAssemblyProject { FileName = "project2.csproj" }; var solution = new Solution(); solution.RootFolder.AddItem(project1); solution.RootFolder.AddItem(project2); solution.RootFolder.AddItem(new UnknownProject { FileName = "project3.csproj" }); TypeSystemService.LoadProject(project1); TypeSystemService.ParseFile(project1, "test.cs", "text/x-csharp", code); var compilation = TypeSystemService.GetCompilation(project1); var typeA = compilation.MainAssembly.GetTypeDefinition("project1", "A", 0); Assert.IsNotNull(typeA); TestCollectProjects(solution, new [] { typeA }, new [] { project1 }); TestCollectProjects(solution, typeA.GetMembers(), new [] { project1 }); TestCollectProjects(solution, typeA.GetMembers(m => m.Name == "Method1"), new [] { project1 }); TestCollectProjects(solution, typeA.GetMembers(m => m.Name == "Method2"), new [] { project1 }); project2.References.Add(new MonoDevelop.Projects.ProjectReference(project1)); var typeB = compilation.MainAssembly.GetTypeDefinition("project1", "B", 0); Assert.IsNotNull(typeB); TestCollectProjects(solution, new [] { typeB }, new Project [] { project1, project2 }); TestCollectProjects(solution, typeB.GetMembers(), new Project [] { project1, project2 }); TestCollectProjects(solution, typeB.GetMembers(m => m.Name == "Method1"), new [] { project1 }); TestCollectProjects(solution, typeB.GetMembers(m => m.Name == "Method2"), new Project [] { project1, project2 }); }
public IType GetCodebehindType(string fileName) { string typeName = GetCodebehindTypeName(fileName); if (typeName != null) { var dom = TypeSystemService.GetCompilation(this); if (dom != null) { return(dom.LookupType(typeName)); } } return(null); }
protected ITypeResolveContext GetContext(ITreeNavigator treeBuilder) { var mainAssembly = GetMainAssembly(treeBuilder); if (mainAssembly != null) { var simpleCompilation = new SimpleCompilation(mainAssembly); return(new SimpleTypeResolveContext(simpleCompilation.MainAssembly)); } var project = (Project)treeBuilder.GetParentDataItem(typeof(Project), true); var compilation = TypeSystemService.GetCompilation(project); return(new SimpleTypeResolveContext(compilation.MainAssembly)); }
protected IType Resolve(ITreeNavigator treeBuilder, IUnresolvedTypeDefinition type) { var mainAssembly = GetMainAssembly(treeBuilder); if (mainAssembly != null) { var simpleCompilation = new SimpleCompilation(mainAssembly); return(type.Resolve(new SimpleTypeResolveContext(simpleCompilation.MainAssembly))); } var project = (Project)treeBuilder.GetParentDataItem(typeof(Project), true); var ctx = TypeSystemService.GetCompilation(project); return(ctx.MainAssembly.GetTypeDefinition(type.Namespace, type.Name, type.TypeParameters.Count)); }
void GetCodeBehind(out IType codeBehindClass, out ICompilation projectDatabase) { codeBehindClass = null; projectDatabase = null; if (HasDoc && !string.IsNullOrEmpty(aspDoc.Info.InheritedClass)) { projectDatabase = TypeSystemService.GetCompilation(project); if (projectDatabase != null) { codeBehindClass = projectDatabase.FindType(aspDoc.Info.InheritedClass); } } }
public IType GetCodebehindType(string fileName) { string typeName = GetCodebehindTypeName(fileName); if (typeName != null) { var dom = TypeSystemService.GetCompilation(this); if (dom != null) { return(ReflectionHelper.ParseReflectionName(typeName).Resolve(dom)); } } return(null); }
void GetCodeBehind(out IType codeBehindClass, out ICompilation projectDatabase) { codeBehindClass = null; projectDatabase = null; if (HasDoc && !string.IsNullOrEmpty(aspDoc.Info.InheritedClass)) { projectDatabase = TypeSystemService.GetCompilation(project); if (projectDatabase != null) { codeBehindClass = ReflectionHelper.ParseReflectionName(aspDoc.Info.InheritedClass).Resolve(projectDatabase); } } }
public void Run() { using (var monitor = IdeApp.Workbench.ProgressMonitors.GetSearchProgressMonitor(true, true)) { foreach (var project in IdeApp.ProjectOperations.CurrentSelectedSolution.GetAllProjects()) { var comp = TypeSystemService.GetCompilation(project); foreach (var type in comp.MainAssembly.GetAllTypeDefinitions()) { if (!type.IsStatic) { continue; } foreach (var method in type.GetMethods(m => m.IsStatic)) { if (!method.IsExtensionMethod) { continue; } IType[] ifTypes; var typeDef = comp.Import(entity); if (typeDef == null) { continue; } if (!CSharpResolver.IsEligibleExtensionMethod(typeDef, method, true, out ifTypes)) { continue; } var tf = TextFileProvider.Instance.GetReadOnlyTextEditorData(method.Region.FileName); var start = tf.LocationToOffset(method.Region.Begin); tf.SearchRequest.SearchPattern = method.Name; var sr = tf.SearchForward(start); if (sr != null) { start = sr.Offset; } monitor.ReportResult(new MemberReference(method, method.Region, start, method.Name.Length)); } } } } }
public ICompilation ResolveAssemblyDom(string assemblyName) { var parsed = SystemAssemblyService.ParseAssemblyName(assemblyName); if (string.IsNullOrEmpty(parsed.Name)) { return(null); } var dllName = parsed.Name + ".dll"; foreach (var reference in References) { if (reference.ReferenceType == ReferenceType.Package || reference.ReferenceType == ReferenceType.Assembly) { foreach (string refPath in reference.GetReferencedFileNames(null)) { if (Path.GetFileName(refPath) == dllName) { return(new ICSharpCode.NRefactory.TypeSystem.Implementation.SimpleCompilation(TypeSystemService.LoadAssemblyContext(TargetRuntime, TargetFramework, refPath))); } } } else if (reference.ReferenceType == ReferenceType.Project && parsed.Name == reference.Reference) { var p = ParentSolution.FindProjectByName(reference.Reference) as DotNetProject; if (p == null) { LoggingService.LogWarning("Project '{0}' referenced from '{1}' could not be found", reference.Reference, this.Name); continue; } return(TypeSystemService.GetCompilation(p)); } } string path = GetAssemblyPath(assemblyName); if (path != null) { return(new ICSharpCode.NRefactory.TypeSystem.Implementation.SimpleCompilation(TypeSystemService.LoadAssemblyContext(TargetRuntime, TargetFramework, path))); } return(null); }
Task <HashSet <IAssembly> > GetAllAssemblies() { var solution = IdeApp.ProjectOperations.CurrentSelectedSolution; return(Task.Factory.StartNew(delegate { var assemblies = new HashSet <IAssembly> (); foreach (var project in solution.GetAllProjects()) { var comp = TypeSystemService.GetCompilation(project); if (comp == null) { continue; } foreach (var asm in comp.Assemblies) { assemblies.Add(asm); } } return assemblies; })); }
protected override SourceCodeLocation GetSourceCodeLocation(string fixtureTypeNamespace, string fixtureTypeName, string methodName) { if (fixtureTypeName == null) { return(null); } var ctx = TypeSystemService.GetCompilation(project); var cls = ctx.MainAssembly.GetTypeDefinition(fixtureTypeNamespace, fixtureTypeName, 0); if (cls == null) { return(null); } if (cls.Name != methodName) { foreach (var met in cls.GetMethods()) { if (met.Name == methodName) { return(new SourceCodeLocation(met.Region.FileName, met.Region.BeginLine, met.Region.BeginColumn)); } } int idx = methodName != null?methodName.IndexOf('(') : -1; if (idx > 0) { methodName = methodName.Substring(0, idx); foreach (var met in cls.GetMethods()) { if (met.Name == methodName) { return(new SourceCodeLocation(met.Region.FileName, met.Region.BeginLine, met.Region.BeginColumn)); } } } } return(new SourceCodeLocation(cls.Region.FileName, cls.Region.BeginLine, cls.Region.BeginColumn)); }
Task <HashSet <IAssembly> > GetAllAssemblies(Project referencedProject) { var solution = IdeApp.ProjectOperations.CurrentSelectedSolution; return(Task.Factory.StartNew(delegate { var assemblies = new HashSet <IAssembly> (); foreach (var project in solution.GetAllProjects()) { if (!IsReferenced(project, referencedProject)) { continue; } var comp = TypeSystemService.GetCompilation(project); if (comp == null) { continue; } assemblies.Add(comp.MainAssembly); } return assemblies; })); }
void FillClasses(MoonlightProject project) { if (classesFilled) { return; } classesFilled = true; try { var dom = TypeSystemService.GetCompilation(project); IType appType = dom.LookupType("System.Windows", "Application"); if (appType == null) { return; } foreach (IType type in appType.GetAllBaseTypes()) { classListStore.AppendValues(type.FullName); } } catch (InvalidOperationException) { // Project not found in parser database } }
public override void DoGlobalOperationOn(IEnumerable <IEntity> entities, Action <RefactoringContext, Script, IEnumerable <AstNode> > callback, string operationName = null) { using (var monitor = IdeApp.Workbench.ProgressMonitors.GetBackgroundProgressMonitor(operationName ?? GettextCatalog.GetString("Performing refactoring task..."), null)) { var col = entities.SelectMany(entity => ReferenceFinder.FindReferences(entity, true, monitor)).OfType <CSharpReferenceFinder.CSharpMemberReference> ().GroupBy(reference => reference.FileName); foreach (var r in col) { string filename = r.Key; bool isOpen; System.Text.Encoding encoding; bool hadBom; var data = TextFileProvider.Instance.GetTextEditorData(filename, out hadBom, out encoding, out isOpen); var firstReference = r.First(); var project = firstReference.Project; ParsedDocument parsedDocument; using (var reader = new StreamReader(data.OpenStream())) parsedDocument = new MonoDevelop.CSharp.Parser.TypeSystemParser().Parse(true, filename, reader, project); var resolver = new CSharpAstResolver(TypeSystemService.GetCompilation(project), firstReference.SyntaxTree, parsedDocument.ParsedFile as CSharpUnresolvedFile); var ctx = new MDRefactoringContext(project as DotNetProject, data, parsedDocument, resolver, firstReference.AstNode.StartLocation, this.context.CancellationToken); var script = new MDRefactoringScript(ctx, FormattingOptions); callback(ctx, script, r.Select(reference => reference.AstNode)); if (!isOpen) { script.Dispose(); Mono.TextEditor.Utils.TextFileUtility.WriteText(filename, data.Text, encoding, hadBom); } } } }
void LoadExceptions() { classes.Add("System.Exception"); if (IdeApp.ProjectOperations.CurrentSelectedProject != null) { var dom = TypeSystemService.GetCompilation(IdeApp.ProjectOperations.CurrentSelectedProject); foreach (var t in dom.FindType(typeof(Exception)).GetSubTypeDefinitions()) { classes.Add(t.ReflectionName); } } else { // no nead to unload this assembly context, it's not cached. var unresolvedAssembly = TypeSystemService.LoadAssemblyContext(Runtime.SystemAssemblyService.CurrentRuntime, MonoDevelop.Core.Assemblies.TargetFramework.Default, typeof(Uri).Assembly.FullName); var mscorlib = TypeSystemService.LoadAssemblyContext(Runtime.SystemAssemblyService.CurrentRuntime, MonoDevelop.Core.Assemblies.TargetFramework.Default, typeof(object).Assembly.FullName); var dom = new ICSharpCode.NRefactory.TypeSystem.Implementation.SimpleCompilation(unresolvedAssembly, mscorlib); foreach (var t in dom.FindType(typeof(Exception)).GetSubTypeDefinitions()) { classes.Add(t.ReflectionName); } } }
void TestCreateInterface(string interfacecode, string outputString, string stubString = null) { var project = new UnknownProject(); project.FileName = "test.csproj"; TypeSystemService.LoadProject(project); TypeSystemService.ParseFile(project, "program.cs", "text/x-csharp", interfacecode); TypeSystemService.ParseFile(project, "stub.cs", "text/x-csharp", "class Stub {\n " + stubString + "}\n"); var wrapper = TypeSystemService.GetProjectContentWrapper(project); wrapper.UpdateContent(c => c.AddAssemblyReferences(new [] { Mscorlib, SystemCore })); var pctx = TypeSystemService.GetCompilation(project); var stubType = pctx.MainAssembly.GetTypeDefinition("", "Stub", 0); var iface = pctx.MainAssembly.GetTypeDefinition("", "ITest", 0); var gen = new CSharpCodeGenerator(); gen.EolMarker = "\n"; gen.Compilation = pctx; string generated = gen.CreateInterfaceImplementation(stubType, stubType.Parts.First(), iface, false); Assert.IsNotEmpty(generated); // crop #region generated = generated.Substring(generated.IndexOf("implementation") + "implementation".Length); generated = generated.Substring(0, generated.LastIndexOf("#")); generated = generated.Trim(); if (outputString != generated) { Console.WriteLine(generated); } Assert.AreEqual(outputString, generated); }
public string[] GetCompatibleMethodsInCodeBehind(MethodInfo methodInfo) { if (fullClass == null) { return(new string[0]); } ParameterInfo[] reflectionParams = methodInfo.GetParameters(); List <IMethod> compatMeth = new List <IMethod> (); IType[] pars = new IType[reflectionParams.Length]; List <IType>[] baseTypes = new List <IType> [reflectionParams.Length]; ICompilation compilation = TypeSystemService.GetCompilation(IdeApp.Workbench.ActiveDocument.Project); for (int i = 0; i < reflectionParams.Length; i++) { pars[i] = reflectionParams[i].ParameterType.ToTypeReference().Resolve(compilation); baseTypes[i] = new List <IType> (pars[i].GetAllBaseTypes()); } var matchMethType = methodInfo.ReturnType.ToTypeReference().Resolve(compilation); foreach (IMethod mmethod in fullClass.GetMethods(null, null, GetMemberOptions.IgnoreInheritedMembers)) { if (mmethod.IsPrivate || mmethod.Parameters.Count != pars.Length || mmethod.IsInternal) { continue; } if (mmethod.ReturnType.FullName != matchMethType.FullName) { continue; } bool allCompatible = true; //compare each parameter for (int i = 0; i < pars.Length; i++) { if (pars[i].FullName != mmethod.Parameters[i].Type.FullName) { allCompatible = false; break; } List <IType> insideBTypes = new List <IType> (mmethod.Parameters[i].Type.GetAllBaseTypes()); if (insideBTypes.Count != baseTypes[i].Count) { allCompatible = false; break; } for (int j = 0; j < baseTypes[i].Count; j++) { if (baseTypes[i][j].FullName != insideBTypes[j].FullName) { allCompatible = false; break; } } } if (allCompatible) { compatMeth.Add(mmethod); } } string[] names = new string[compatMeth.Count]; for (int i = 0; i < names.Length; i++) { names[i] = compatMeth[i].Name; } return(names); }
public IEnumerable <CompletionData> GetControlCompletionData() { return(GetControlCompletionData(ReflectionHelper.ParseReflectionName("System.Web.UI.Control").Resolve(TypeSystemService.GetCompilation(Project)))); }
/// Adds a field to the class public void BindToField(Stetic.Component obj) { if (targetObject == null) { return; } string name = GetMemberName(obj); var cls = GetClass(); if (FindField(cls.Resolve(project), name) != null) { return; } Document doc = IdeApp.Workbench.OpenDocument(cls.Region.FileName, true); IEditableTextFile editor = doc.GetContent <IEditableTextFile> (); if (editor != null) { var resolvedCls = cls.Resolve(cls.UnresolvedFile.GetTypeResolveContext(TypeSystemService.GetCompilation(project), cls.Region.Begin)).GetDefinition(); CodeGenerationService.AddNewMember(resolvedCls, cls, GetFieldCode(cls, obj, name)); } }
static IEnumerable <PossibleNamespace> GetPossibleNamespaces(Document doc, AstNode node, ResolveResult resolveResult, DocumentLocation location) { var unit = doc.ParsedDocument.GetAst <SyntaxTree> (); if (unit == null) { yield break; } var project = doc.Project; if (project == null) { yield break; } int tc = GetTypeParameterCount(node); var attribute = unit.GetNodeAt <ICSharpCode.NRefactory.CSharp.Attribute> (location); bool isInsideAttributeType = attribute != null && attribute.Type.Contains(location); var compilations = new List <Tuple <ICompilation, MonoDevelop.Projects.ProjectReference> > (); compilations.Add(Tuple.Create(doc.Compilation, (MonoDevelop.Projects.ProjectReference)null)); var referencedItems = IdeApp.Workspace != null?project.GetReferencedItems(IdeApp.Workspace.ActiveConfiguration).ToList() : (IEnumerable <SolutionItem>) new SolutionItem[0]; var solution = project != null ? project.ParentSolution : null; if (solution != null) { foreach (var curProject in solution.GetAllProjects()) { if (curProject == project || referencedItems.Contains(curProject)) { continue; } var comp = TypeSystemService.GetCompilation(curProject); if (comp == null) { continue; } compilations.Add(Tuple.Create(comp, new MonoDevelop.Projects.ProjectReference(curProject))); } } var netProject = project as DotNetProject; if (netProject == null) { yield break; } var frameworkLookup = TypeSystemService.GetFrameworkLookup(netProject); if (resolveResult is UnknownMemberResolveResult) { var umResult = (UnknownMemberResolveResult)resolveResult; foreach (var r in frameworkLookup.LookupExtensionMethod(umResult.MemberName)) { var systemAssembly = netProject.AssemblyContext.GetAssemblyFromFullName(r.FullName, r.Package, netProject.TargetFramework); if (systemAssembly == null) { continue; } compilations.Add(Tuple.Create(TypeSystemService.GetCompilation(systemAssembly, doc.Compilation), new MonoDevelop.Projects.ProjectReference(systemAssembly))); } } bool foundIdentifier = false; var lookup = new MemberLookup(null, doc.Compilation.MainAssembly); foreach (var comp in compilations) { var compilation = comp.Item1; var requiredReference = comp.Item2; if (resolveResult is AmbiguousTypeResolveResult) { if (compilation != doc.Compilation) { continue; } var aResult = resolveResult as AmbiguousTypeResolveResult; var file = doc.ParsedDocument.ParsedFile as CSharpUnresolvedFile; var scope = file.GetUsingScope(location).Resolve(compilation); while (scope != null) { foreach (var u in scope.Usings) { foreach (var typeDefinition in u.Types) { if (typeDefinition.Name == aResult.Type.Name && typeDefinition.TypeParameterCount == tc && lookup.IsAccessible(typeDefinition, false)) { yield return(new PossibleNamespace(typeDefinition.Namespace, true, requiredReference)); } } } scope = scope.Parent; } } var allTypes = compilation == doc.Compilation ? compilation.GetAllTypeDefinitions() : compilation.MainAssembly.GetAllTypeDefinitions(); if (resolveResult is UnknownIdentifierResolveResult) { var uiResult = resolveResult as UnknownIdentifierResolveResult; string possibleAttributeName = isInsideAttributeType ? uiResult.Identifier + "Attribute" : uiResult.Identifier; foreach (var typeDefinition in allTypes) { if (typeDefinition.Name == possibleAttributeName && typeDefinition.TypeParameterCount == tc && lookup.IsAccessible(typeDefinition, false)) { if (typeDefinition.DeclaringTypeDefinition != null) { var builder = new TypeSystemAstBuilder(new CSharpResolver(doc.Compilation)); foundIdentifier = true; yield return(new PossibleNamespace(builder.ConvertType(typeDefinition.DeclaringTypeDefinition).ToString(), false, requiredReference)); } else { foundIdentifier = true; yield return(new PossibleNamespace(typeDefinition.Namespace, true, requiredReference)); } } } } if (resolveResult is UnknownMemberResolveResult) { var umResult = (UnknownMemberResolveResult)resolveResult; string possibleAttributeName = isInsideAttributeType ? umResult.MemberName + "Attribute" : umResult.MemberName; foreach (var typeDefinition in allTypes.Where(t => t.HasExtensionMethods)) { foreach (var method in typeDefinition.Methods.Where(m => m.IsExtensionMethod && m.Name == possibleAttributeName)) { IType[] inferredTypes; if (CSharpResolver.IsEligibleExtensionMethod( compilation.Import(umResult.TargetType), method, true, out inferredTypes )) { yield return(new PossibleNamespace(typeDefinition.Namespace, true, requiredReference)); goto skipType; } } skipType: ; } } if (resolveResult is ErrorResolveResult) { var identifier = unit != null?unit.GetNodeAt <Identifier> (location) : null; if (identifier != null) { var uiResult = resolveResult as UnknownIdentifierResolveResult; if (uiResult != null) { string possibleAttributeName = isInsideAttributeType ? uiResult.Identifier + "Attribute" : uiResult.Identifier; foreach (var typeDefinition in allTypes) { if ((identifier.Name == possibleAttributeName) && typeDefinition.TypeParameterCount == tc && lookup.IsAccessible(typeDefinition, false)) { yield return(new PossibleNamespace(typeDefinition.Namespace, true, requiredReference)); } } } } } } // Try to search framework types if (!foundIdentifier && resolveResult is UnknownIdentifierResolveResult) { var uiResult = resolveResult as UnknownIdentifierResolveResult; string possibleAttributeName = isInsideAttributeType ? uiResult.Identifier + "Attribute" : uiResult.Identifier; foreach (var r in frameworkLookup.LookupIdentifier(possibleAttributeName, tc)) { var systemAssembly = netProject.AssemblyContext.GetAssemblyFromFullName(r.FullName, r.Package, netProject.TargetFramework); if (systemAssembly == null) { continue; } yield return(new PossibleNamespace(r.Namespace, true, new MonoDevelop.Projects.ProjectReference(systemAssembly))); } } }
public IEnumerable <CompletionData> GetControlCompletionData() { return(GetControlCompletionData(TypeSystemService.GetCompilation(Project).LookupType("System.Web.UI", "Control"))); }
public void Run() { var assemblies = new HashSet <IAssembly> (); foreach (var project in IdeApp.ProjectOperations.CurrentSelectedSolution.GetAllProjects()) { var comp = TypeSystemService.GetCompilation(project); if (comp == null) { continue; } assemblies.Add(comp.MainAssembly); } TypeGraph tg = new TypeGraph(assemblies); var node = tg.GetNode(entity.DeclaringTypeDefinition); using (var monitor = IdeApp.Workbench.ProgressMonitors.GetSearchProgressMonitor(true, true)) { Stack <IList <TypeGraphNode> > derivedTypes = new Stack <IList <TypeGraphNode> > (); derivedTypes.Push(node.DerivedTypes); HashSet <ITypeDefinition> visitedType = new HashSet <ITypeDefinition> (); while (derivedTypes.Count > 0) { foreach (var derived in derivedTypes.Pop()) { if (visitedType.Contains(derived.TypeDefinition)) { continue; } derivedTypes.Push(tg.GetNode(derived.TypeDefinition).DerivedTypes); visitedType.Add(derived.TypeDefinition); var impMember = derived.TypeDefinition.Compilation.Import(entity); if (impMember == null) { continue; } IMember derivedMember; if (entity.DeclaringTypeDefinition.Kind == TypeKind.Interface) { derivedMember = derived.TypeDefinition.GetMembers(null, GetMemberOptions.IgnoreInheritedMembers).FirstOrDefault( m => m.ImplementedInterfaceMembers.Any(im => im.Region == entity.Region) ); } else { derivedMember = InheritanceHelper.GetDerivedMember(impMember, derived.TypeDefinition); } if (derivedMember == null) { continue; } var tf = TextFileProvider.Instance.GetReadOnlyTextEditorData(derivedMember.Region.FileName); var start = tf.LocationToOffset(derivedMember.Region.Begin); tf.SearchRequest.SearchPattern = derivedMember.Name; var sr = tf.SearchForward(start); if (sr != null) { start = sr.Offset; } monitor.ReportResult(new MemberReference(derivedMember, derivedMember.Region, start, derivedMember.Name.Length)); } } } }
static IEnumerable <Project> GetAllReferencingProjects(Solution solution, string assemblyName) { return(solution.GetAllProjects().Where( project => TypeSystemService.GetCompilation(project).Assemblies.Any(a => a.AssemblyName == assemblyName))); }
public override IEnumerable <MemberReference> FindReferences(Project project, IProjectContent content, IEnumerable <FilePath> possibleFiles, IProgressMonitor monitor, IEnumerable <object> members) { if (content == null) { throw new ArgumentNullException("content", "Project content not set."); } SetPossibleFiles(possibleFiles); SetSearchedMembers(members); var scopes = searchedMembers.Select(e => e is IEntity ? refFinder.GetSearchScopes((IEntity)e) : refFinder.GetSearchScopes((INamespace)e)); var compilation = project != null?TypeSystemService.GetCompilation(project) : content.CreateCompilation(); List <MemberReference> refs = new List <MemberReference> (); foreach (var opendoc in openDocuments) { foreach (var newRef in FindInDocument(opendoc.Item2)) { if (newRef == null || refs.Any(r => r.FileName == newRef.FileName && r.Region == newRef.Region)) { continue; } refs.Add(newRef); } } foreach (var file in files) { if (monitor != null) { monitor.Step(1); } string text = Mono.TextEditor.Utils.TextFileUtility.ReadAllText(file); if (memberName != null && text.IndexOf(memberName, StringComparison.Ordinal) < 0 && (keywordName == null || text.IndexOf(keywordName, StringComparison.Ordinal) < 0)) { continue; } using (var editor = TextEditorData.CreateImmutable(text)) { editor.Document.FileName = file; var unit = new PlayScriptParser().Parse(editor); if (unit == null) { continue; } var storedFile = content.GetFile(file); var parsedFile = storedFile as CSharpUnresolvedFile; if (parsedFile == null && storedFile is ParsedDocumentDecorator) { parsedFile = ((ParsedDocumentDecorator)storedFile).ParsedFile as CSharpUnresolvedFile; } if (parsedFile == null) { // for fallback purposes - should never happen. parsedFile = unit.ToTypeSystem(); content = content.AddOrUpdateFiles(parsedFile); compilation = content.CreateCompilation(); } foreach (var scope in scopes) { refFinder.FindReferencesInFile( scope, parsedFile, unit, compilation, (astNode, result) => { var newRef = GetReference(project, result, astNode, unit, file, editor); if (newRef == null || refs.Any(r => r.FileName == newRef.FileName && r.Region == newRef.Region)) { return; } refs.Add(newRef); }, CancellationToken.None ); } } } return(refs); }
public static void FindDerivedClasses(ITypeDefinition cls) { var solution = IdeApp.ProjectOperations.CurrentSelectedSolution; if (solution == null) { return; } var sourceProject = TypeSystemService.GetProject(cls); if (sourceProject == null) { return; } var projects = ReferenceFinder.GetAllReferencingProjects(solution, sourceProject); ThreadPool.QueueUserWorkItem(delegate { using (var monitor = IdeApp.Workbench.ProgressMonitors.GetSearchProgressMonitor(true, true)) { var cache = new Dictionary <string, TextEditorData> (); Parallel.ForEach(projects, p => { var comp = TypeSystemService.GetCompilation(p); if (comp == null) { return; } var importedType = comp.Import(cls); if (importedType == null) { return; } foreach (var type in comp.MainAssembly.GetAllTypeDefinitions()) { if (!type.IsDerivedFrom(importedType)) { continue; } TextEditorData textFile; if (!cache.TryGetValue(type.Region.FileName, out textFile)) { cache [type.Region.FileName] = textFile = TextFileProvider.Instance.GetTextEditorData(type.Region.FileName); } int position = textFile.LocationToOffset(type.Region.Begin); string keyword; switch (type.Kind) { case TypeKind.Interface: keyword = "interface"; break; case TypeKind.Struct: keyword = "struct"; break; case TypeKind.Delegate: keyword = "delegate"; break; case TypeKind.Enum: keyword = "enum"; break; default: keyword = "class"; break; } while (position < textFile.Length - keyword.Length) { if (textFile.GetTextAt(position, keyword.Length) == keyword) { position += keyword.Length; while (position < textFile.Length && textFile.GetCharAt(position) == ' ' || textFile.GetCharAt(position) == '\t') { position++; } break; } position++; } monitor.ReportResult(new MonoDevelop.Ide.FindInFiles.SearchResult(new FileProvider(type.Region.FileName, p), position, 0)); } }); foreach (var tf in cache.Values) { if (tf.Parent == null) { tf.Dispose(); } } } }); }
/*public override void RunParameterCompletionCommand () * { * if (localDocumentInfo == null) { * base.RunParameterCompletionCommand (); * return; * } * var doc = document; * document = localDocumentInfo.HiddenDocument; * var cw = CompletionWidget; * CompletionWidget = documentBuilder.CreateCompletionWidget (localDocumentInfo); * try { * base.RunParameterCompletionCommand (); * } finally { * document = doc; * CompletionWidget = cw; * } * }*/ protected override void GetElementCompletions(CompletionDataList list) { S.XName parentName = GetParentElementName(0); //fallback if (!HasDoc) { AddAspBeginExpressions(list); string aspPrefix = "asp:"; var type = ReflectionHelper.ParseReflectionName("System.Web.UI.Control").Resolve(TypeSystemService.GetCompilation(project)); foreach (var cls in WebTypeContext.ListSystemControlClasses(type, project)) { list.Add(new AspTagCompletionData(aspPrefix, cls)); } base.GetElementCompletions(list); return; } IType controlClass = null; if (parentName.HasPrefix) { controlClass = refman.GetControlType(parentName.Prefix, parentName.Name); } else { S.XName grandparentName = GetParentElementName(1); if (grandparentName.IsValid && grandparentName.HasPrefix) { controlClass = refman.GetControlType(grandparentName.Prefix, grandparentName.Name); } } //we're just in HTML if (controlClass == null) { //root element? if (!parentName.IsValid) { if (aspDoc.Info.Subtype == WebSubtype.WebControl) { AddHtmlTagCompletionData(list, Schema, new S.XName("div")); AddAspBeginExpressions(list); list.AddRange(refman.GetControlCompletionData()); AddMiscBeginTags(list); } else if (!string.IsNullOrEmpty(aspDoc.Info.MasterPageFile)) { //FIXME: add the actual region names list.Add(new CompletionData("asp:Content")); } } else { AddAspBeginExpressions(list); list.AddRange(refman.GetControlCompletionData()); base.GetElementCompletions(list); } return; } string defaultProp; bool childrenAsProperties = AreChildrenAsProperties(controlClass, out defaultProp); if (defaultProp != null && defaultProp.Length == 0) { defaultProp = null; } //parent permits child controls directly if (!childrenAsProperties) { AddAspBeginExpressions(list); list.AddRange(refman.GetControlCompletionData()); AddMiscBeginTags(list); //TODO: get correct parent for Content tags AddHtmlTagCompletionData(list, Schema, new S.XName("body")); return; } //children of properties if (childrenAsProperties && (!parentName.HasPrefix || defaultProp != null)) { if (controlClass.GetProjectContent() == null) { LoggingService.LogWarning("IType {0} does not have a SourceProjectDom", controlClass); return; } string propName = defaultProp ?? parentName.Name; IProperty property = controlClass.GetProperties() .Where(x => string.Compare(propName, x.Name, StringComparison.OrdinalIgnoreCase) == 0) .FirstOrDefault(); if (property == null) { return; } //sanity checks on attributes switch (GetPersistenceMode(property)) { case System.Web.UI.PersistenceMode.Attribute: case System.Web.UI.PersistenceMode.EncodedInnerDefaultProperty: return; case System.Web.UI.PersistenceMode.InnerDefaultProperty: if (!parentName.HasPrefix) { return; } break; case System.Web.UI.PersistenceMode.InnerProperty: if (parentName.HasPrefix) { return; } break; } //check if allows freeform ASP/HTML content if (property.ReturnType.ToString() == "System.Web.UI.ITemplate") { AddAspBeginExpressions(list); AddMiscBeginTags(list); AddHtmlTagCompletionData(list, Schema, new S.XName("body")); list.AddRange(refman.GetControlCompletionData()); return; } //FIXME:unfortunately ASP.NET doesn't seem to have enough type information / attributes //to be able to resolve the correct child types here //so we assume it's a list and have a quick hack to find arguments of strongly typed ILists IType collectionType = property.ReturnType; if (collectionType == null) { list.AddRange(refman.GetControlCompletionData()); return; } string addStr = "Add"; IMethod meth = collectionType.GetMethods() .Where(m => m.Parameters.Count == 1 && m.Name == addStr).FirstOrDefault(); if (meth != null) { IType argType = meth.Parameters [0].Type; var type = ReflectionHelper.ParseReflectionName("System.Web.UI.Control").Resolve(argType.GetDefinition().Compilation); if (argType != null && argType.IsBaseType(type)) { list.AddRange(refman.GetControlCompletionData(argType)); return; } } list.AddRange(refman.GetControlCompletionData()); return; } //properties as children of controls if (parentName.HasPrefix && childrenAsProperties) { if (controlClass.GetProjectContent() == null) { LoggingService.LogWarning("IType {0} does not have a SourceProjectDom", controlClass); } foreach (IProperty prop in GetUniqueMembers <IProperty> (controlClass.GetProperties())) { if (GetPersistenceMode(prop) != System.Web.UI.PersistenceMode.Attribute) { list.Add(prop.Name, prop.GetStockIcon(), AmbienceService.GetSummaryMarkup(prop)); } } return; } }
void StartAnalyzation(object sender, EventArgs e) { var solution = IdeApp.ProjectOperations.CurrentSelectedSolution; if (solution == null) { return; } runButton.Sensitive = false; store.Clear(); var rootNode = store.AddNode(); rootNode.SetValue(text, "Analyzing..."); ThreadPool.QueueUserWorkItem(delegate { using (var monitor = IdeApp.Workbench.ProgressMonitors.GetStatusProgressMonitor("Analyzing solution", null, false)) { int work = 0; foreach (var project in solution.GetAllProjects()) { work += project.Files.Count(f => f.BuildAction == BuildAction.Compile); } monitor.BeginTask("Analyzing solution", work); int allIssues = 0; TypeSystemParser parser = null; string lastMime = null; CodeIssueProvider[] codeIssueProvider = null; foreach (var project in solution.GetAllProjects()) { var compilation = TypeSystemService.GetCompilation(project); List <CodeIssue> codeIssues = new List <CodeIssue> (); Parallel.ForEach(project.Files, file => { if (file.BuildAction != BuildAction.Compile) { return; } var editor = TextFileProvider.Instance.GetReadOnlyTextEditorData(file.FilePath); if (lastMime != editor.MimeType || parser == null) { parser = TypeSystemService.GetParser(editor.MimeType); } if (parser == null) { return; } var reader = new StreamReader(editor.OpenStream()); var document = parser.Parse(true, editor.FileName, reader, project); reader.Close(); if (document == null) { return; } var resolver = new CSharpAstResolver(compilation, document.GetAst <SyntaxTree> (), document.ParsedFile as CSharpUnresolvedFile); var context = document.CreateRefactoringContextWithEditor(editor, resolver, CancellationToken.None); if (lastMime != editor.MimeType || codeIssueProvider == null) { codeIssueProvider = RefactoringService.GetInspectors(editor.MimeType).ToArray(); } Parallel.ForEach(codeIssueProvider, (provider) => { var severity = provider.GetSeverity(); if (severity == Severity.None) { return; } try { foreach (var r in provider.GetIssues(context, CancellationToken.None)) { lock (codeIssues) { codeIssues.Add(r); } } } catch (Exception ex) { LoggingService.LogError("Error while running code issue on:" + editor.FileName, ex); } }); lastMime = editor.MimeType; monitor.Step(1); }); Application.Invoke(delegate { var projectNode = store.AddNode(); projectNode.SetValue(text, project.Name + "( " + codeIssues.Count + " issues)"); foreach (var issue in codeIssues) { var child = projectNode.AddChild(); child.SetValue(text, issue.Description + " - " + issue.Region); child.SetValue(region, issue.Region); child.MoveToParent(); } projectNode.MoveToParent(); allIssues += codeIssues.Count; }); } Application.Invoke(delegate { rootNode.SetValue(text, "Found issues :" + allIssues); runButton.Sensitive = true; }); monitor.EndTask(); } }); }