public ProjectDom 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(ProjectDomService.GetAssemblyDom(TargetRuntime, 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(ProjectDomService.GetProjectDom(p)); } } string path = GetAssemblyPath(assemblyName); if (path != null) { return(ProjectDomService.GetAssemblyDom(TargetRuntime, path)); } return(null); }
protected override SourceCodeLocation GetSourceCodeLocation(string fullClassName, string methodName) { ProjectDom ctx = ProjectDomService.GetProjectDom(project); IType cls = ctx.GetType(fullClassName); if (cls == null) { return(null); } foreach (IMethod met in cls.Methods) { if (met.Name == methodName) { return(new SourceCodeLocation(cls.CompilationUnit.FileName, met.Location.Line, met.Location.Column)); } } return(new SourceCodeLocation(cls.CompilationUnit.FileName, cls.Location.Line, cls.Location.Column)); }
public TypeUpdateInformation UpdateFromParseInfo(ICompilationUnit parserInfo, string fileName) { lock (rwlock) { ICompilationUnit cu = parserInfo; List <IType> resolved; List <IAttribute> resolvedAtts; int unresolvedCount = ResolveTypes(cu, cu.Types, cu.Attributes, out resolved, out resolvedAtts); totalUnresolvedCount += unresolvedCount; TypeUpdateInformation res = UpdateTypeInformation(resolved, resolvedAtts, parserInfo.FileName); FileEntry file; if (files.TryGetValue(fileName, out file)) { if (unresolvedCount > 0) { if (file.ParseErrorRetries != 1) { file.ParseErrorRetries = 1; // Enqueue the file for quickly reparse. Types can't be resolved most probably because // the file that implements them is not yet parsed. ProjectDomService.QueueParseJob(SourceProjectDom, delegate { UpdateFromParseInfo(parserInfo, fileName); }, file.FileName); } } else { file.ParseErrorRetries = 0; } } if ((++parseCount % MAX_ACTIVE_COUNT) == 0) { Flush(); } return(res); } }
void CollectTypes() { lock (types) { getTypesTimer.BeginTiming(); try { foreach (Document doc in IdeApp.Workbench.Documents) { // We only want to check it here if it's not part // of the open combine. Otherwise, it will get // checked down below. if (doc.Project == null && doc.IsFile) { ICompilationUnit info = doc.CompilationUnit; if (info != null) { foreach (IType c in info.Types) { types.Add(c); } } } } ReadOnlyCollection <Project> projects = IdeApp.Workspace.GetAllProjects(); foreach (Project p in projects) { ProjectDom dom = ProjectDomService.GetProjectDom(p); if (dom == null) { continue; } foreach (IType c in dom.Types) { AddType(c, types); } } } finally { getTypesTimer.EndTiming(); } } }
public ConditinalExpressionEvaluator(Mono.TextEditor.Document doc) { var project = IdeApp.ProjectOperations.CurrentSelectedProject; if (project != null) { DotNetProjectConfiguration configuration = project.GetConfiguration(IdeApp.Workspace.ActiveConfiguration) as DotNetProjectConfiguration; if (configuration != null) { CSharpCompilerParameters cparams = configuration.CompilationParameters as CSharpCompilerParameters; if (cparams != null) { string[] syms = cparams.DefineSymbols.Split(';', ',', ' ', '\t'); foreach (string s in syms) { string ss = s.Trim(); if (ss.Length > 0 && !symbols.Contains(ss)) { symbols.Add(ss); } } } } else { Console.WriteLine("NO CONFIGURATION"); } } ProjectDom dom = ProjectDomService.GetProjectDom(project); ParsedDocument parsedDocument = ProjectDomService.GetParsedDocument(dom, doc.FileName); /* if (parsedDocument == null) * parsedDocument = ProjectDomService.ParseFile (dom, doc.FileName ?? "a.cs", delegate { return doc.Text; });*/ if (parsedDocument != null) { foreach (PreProcessorDefine define in parsedDocument.Defines) { symbols.Add(define.Define); } } }
public static void AddNewMembers(IType type, IEnumerable <IMember> newMembers, string regionName = null, Func <IMember, bool> implementExplicit = null) { IMember firstNewMember = newMembers.FirstOrDefault(); if (firstNewMember == null) { return; } bool isOpen; var data = TextFileProvider.Instance.GetTextEditorData(type.CompilationUnit.FileName, out isOpen); var parsedDocument = ProjectDomService.GetParsedDocument(type.SourceProjectDom, type.CompilationUnit.FileName); var insertionPoints = GetInsertionPoints(data, parsedDocument, type); var suitableInsertionPoint = GetSuitableInsertionPoint(insertionPoints, type, firstNewMember); var generator = CreateCodeGenerator(data); generator.IndentLevel = CalculateBodyIndentLevel(parsedDocument.CompilationUnit.GetTypeAt(type.Location)); StringBuilder sb = new StringBuilder(); foreach (IMember newMember in newMembers) { if (sb.Length > 0) { sb.AppendLine(); sb.AppendLine(); } sb.Append(generator.CreateMemberImplementation(type, newMember, implementExplicit != null ? implementExplicit(newMember) : false).Code); } suitableInsertionPoint.Insert(data, string.IsNullOrEmpty(regionName) ? sb.ToString() : generator.WrapInRegions(regionName, sb.ToString())); if (!isOpen) { try { File.WriteAllText(type.CompilationUnit.FileName, data.Text); } catch (Exception e) { LoggingService.LogError(GettextCatalog.GetString("Failed to write file '{0}'.", type.CompilationUnit.FileName), e); MessageService.ShowError(GettextCatalog.GetString("Failed to write file '{0}'.", type.CompilationUnit.FileName)); } } }
void RunFormatter() { if (PropertyService.Get("OnTheFlyFormatting", false) && textEditorData != null) { textEditorData.Paste -= TextEditorDataPaste; // textEditorData.Document.TextReplaced -= TextCut; ProjectDom dom = ProjectDomService.GetProjectDom(Document.Project); if (dom == null) { dom = ProjectDomService.GetFileDom(Document.FileName); } DomLocation location = new DomLocation(textEditorData.Caret.Location.Line + (lastCharInserted == '\n' ? -1 : 0), textEditorData.Caret.Location.Column); // CSharpFormatter.Format (textEditorData, dom, Document.CompilationUnit, location); OnTheFlyFormatter.Format(Document, dom, location, lastCharInserted == '\n'); // textEditorData.Document.TextReplaced += TextCut; textEditorData.Paste += TextEditorDataPaste; } }
protected override void ParseFile(string fileName, IProgressMonitor monitor) { if (monitor != null) { monitor.BeginTask(string.Format(GettextCatalog.GetString("Parsing file: {0}"), Path.GetFileName(fileName)), 1); } try { ProjectDomService.Parse(this.project, fileName, null, delegate() { return(File.ReadAllText(fileName)); }); // The call to ProjectDomService.Parse will call UpdateFromParseInfo when done } finally { if (monitor != null) { monitor.EndTask(); } } }
IMember GetMemberToDocument() { var parsedDocument = ProjectDomService.Parse(Document.Project, Document.FileName, Document.TextEditorData.Document.MimeType, Document.TextEditorData.Document.Text); IType type = parsedDocument.CompilationUnit.GetTypeAt(textEditorData.Caret.Line, textEditorData.Caret.Column); if (type == null) { return(null); } IMember result = null; foreach (IMember member in type.Members) { if (member.Location > new DomLocation(textEditorData.Caret.Line + 1, textEditorData.Caret.Column + 1) && (result == null || member.Location < result.Location)) { result = member; } } return(result); }
public override IEnumerable <MemberReference> FindMemberReferences(RefactorerContext ctx, string fileName, IType cls, IMember member, bool includeXmlComment) { var editor = ((Mono.TextEditor.ITextEditorDataProvider)ctx.GetFile(fileName)).GetTextEditorData(); var doc = ProjectDomService.GetParsedDocument(ctx.ParserContext, fileName); if (doc == null || doc.CompilationUnit == null) { return(null); } NRefactoryResolver resolver = new NRefactoryResolver(ctx.ParserContext, doc.CompilationUnit, ICSharpCode.OldNRefactory.SupportedLanguage.CSharp, editor, fileName); resolver.CallingMember = member; FindMemberAstVisitor visitor = new FindMemberAstVisitor(editor.Document, member); visitor.IncludeXmlDocumentation = includeXmlComment; visitor.RunVisitor(resolver); SetContext(visitor.FoundReferences, ctx); return(visitor.FoundReferences); }
public override void Setup() { base.Setup(); string solFile = Util.GetSampleProject("completion-db-test", "CompletionDbTest.sln"); solution = (Solution)Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile); ProjectDomService.Load(solution); Project prj; prj = solution.FindProjectByName("Library2"); lib2 = ProjectDomService.GetProjectDom(prj); lib2.ForceUpdate(true); prj = solution.FindProjectByName("Library1"); lib1 = ProjectDomService.GetProjectDom(prj); lib1.ForceUpdate(true); prj = solution.FindProjectByName("CompletionDbTest"); mainProject = ProjectDomService.GetProjectDom(prj); mainProject.ForceUpdate(true); }
/// <summary> /// This method can take some time to finish. It's not threaded /// </summary> /// <returns> /// A <see cref="ParsedDocument"/> that contains the current dom. /// </returns> public ParsedDocument UpdateParseDocument() { try { string currentParseFile = FileName; var editor = Editor; if (editor == null) { return(null); } string currentParseText = editor.Text; Project curentParseProject = Project; this.parsedDocument = ProjectDomService.Parse(curentParseProject, currentParseFile, currentParseText); if (this.parsedDocument != null && !this.parsedDocument.HasErrors) { this.lastErrorFreeParsedDocument = parsedDocument; } } finally { OnDocumentParsed(EventArgs.Empty); } return(this.parsedDocument); }
public string GetExpression(int offset) { string fileName = View.ContentName; if (fileName == null) { fileName = View.UntitledName; } IExpressionFinder expressionFinder = ProjectDomService.GetExpressionFinder(fileName); string expression = expressionFinder == null?GetExpressionBeforeOffset(offset) : expressionFinder.FindFullExpression(Document.Text, offset).Expression; if (expression == null) { return(string.Empty); } else { return(expression.Trim()); } }
static ProjectDom GetSystemWebDom(TargetRuntime runtime, TargetFramework targetFramework) { string file = runtime.AssemblyContext.GetAssemblyNameForVersion(sysWebAssemblyName, targetFramework); if (string.IsNullOrEmpty(file)) { throw new Exception("System.Web assembly name not found for framework " + targetFramework.Id); } file = runtime.AssemblyContext.GetAssemblyLocation(file, targetFramework); if (string.IsNullOrEmpty(file)) { throw new Exception("System.Web assembly file not found for framework " + targetFramework.Id); } ProjectDom dom = ProjectDomService.GetAssemblyDom(runtime, file); if (dom == null) { throw new Exception("System.Web parse database not found for framework " + targetFramework.Id + " file '" + file + "'"); } return(dom); }
public IEnumerable <Tuple <ProjectDom, FilePath> > GetFileNames(Solution solution, ProjectDom dom, ICompilationUnit unit, IProgressMonitor monitor) { int counter = 0; ReadOnlyCollection <Project> allProjects = solution.GetAllProjects(); if (monitor != null) { monitor.BeginTask(GettextCatalog.GetString("Finding references in solution..."), allProjects.Sum <Project>(p => p.Files.Count)); } foreach (Project project in allProjects) { if (monitor != null && monitor.IsCancelRequested) { yield break; } ProjectDom currentDom = ProjectDomService.GetProjectDom(project); foreach (ProjectFile projectFile in (Collection <ProjectFile>)project.Files) { if (monitor != null && monitor.IsCancelRequested) { yield break; } yield return(Tuple.Create <ProjectDom, FilePath>(currentDom, projectFile.FilePath)); if (monitor != null) { if (counter % 10 == 0) { monitor.Step(10); } ++counter; } } } if (monitor != null) { monitor.EndTask(); } }
void FillClasses(MoonlightProject project) { if (classesFilled) { return; } classesFilled = true; try { ProjectDom dom = ProjectDomService.GetProjectDom(project); IType appType = dom.GetType("System.Windows.Application", true); if (appType == null) { return; } foreach (IType type in dom.GetSubclasses(appType, false)) { classListStore.AppendValues(type.FullName); } } catch (InvalidOperationException) { // Project not found in parser database } }
/// Synchronizes the bindings between the object and the source code public void UpdateBindings(string fileName) { if (targetObject == null) { return; } ParsedDocument doc = ProjectDomService.Parse(project, fileName, null); classFile = fileName; if (doc != null && doc.CompilationUnit != null) { IType cls = GetClass(); UpdateBindings(targetObject, cls); if (cls != null) { targetObject.GeneratePublic = cls.IsPublic; } } }
public override void BuildChildNodes(ITreeBuilder treeBuilder, object dataObject) { PackageNode packageNode = dataObject as PackageNode; PythonParsedDocument parsed = ProjectDomService.ParseFile(null, packageNode.ProjectFile.Name) as PythonParsedDocument; if (parsed != null && parsed.Module != null) { foreach (PythonClass pyClass in parsed.Module.Classes) { treeBuilder.AddChild(pyClass); } foreach (PythonAttribute pyAttr in parsed.Module.Attributes) { treeBuilder.AddChild(pyAttr); } foreach (PythonFunction pyFunc in parsed.Module.Functions) { treeBuilder.AddChild(pyFunc); } } }
bool AnalyzeTargetExpression(RefactoringOptions options, MonoDevelop.CSharp.Ast.CompilationUnit unit) { var data = options.GetTextEditorData(); var target = unit.GetNodeAt(data.Caret.Line, data.Caret.Column); if (target == null) { return(false); } if (target.Parent is MemberReferenceExpression && ((MemberReferenceExpression)target.Parent).GetChildByRole(MemberReferenceExpression.Roles.Identifier) == target) { var memberReference = (MemberReferenceExpression)target.Parent; target = memberReference.Target; var targetResult = options.GetResolver().Resolve(new ExpressionResult(data.GetTextBetween(target.StartLocation.Line, target.StartLocation.Column, target.EndLocation.Line, target.EndLocation.Column)), resolvePosition); if (targetResult.StaticResolve) { modifiers = MonoDevelop.Projects.Dom.Modifiers.Static; } declaringType = options.Dom.GetType(targetResult.ResolvedType); methodName = memberReference.MemberName; } else if (target is Identifier) { declaringType = options.ResolveResult.CallingType; methodName = data.GetTextBetween(target.StartLocation.Line, target.StartLocation.Column, target.EndLocation.Line, target.EndLocation.Column); } if (declaringType != null && !HasCompatibleMethod(declaringType, methodName, invocation)) { if (declaringType.HasParts) { declaringType = declaringType.Parts.FirstOrDefault(t => t.CompilationUnit.FileName == options.Document.FileName) ?? declaringType; } var doc = ProjectDomService.GetParsedDocument(declaringType.SourceProjectDom, declaringType.CompilationUnit.FileName); declaringType = doc.CompilationUnit.GetTypeAt(declaringType.Location) ?? declaringType; return(true); } return(false); }
void LoadSolutionContents(Solution sln) { loadedSlns.Add(sln); // Load all tags that are stored in pidb files foreach (Project p in sln.GetAllProjects()) { ProjectDom pContext = ProjectDomService.GetProjectDom(p); if (pContext == null) { continue; } foreach (ProjectFile file in p.Files) { IList <Tag> tags = pContext.GetSpecialComments(file.Name); if (tags != null && tags.Count > 0) { UpdateCommentTags(sln, file.Name, tags); } } } }
public Gtk.Window CreateTooltipWindow(Mono.TextEditor.TextEditor editor, int offset, Gdk.ModifierType modifierState, TooltipItem item) { ExtensibleTextEditor ed = (ExtensibleTextEditor)editor; ParsedDocument doc = ProjectDomService.GetParsedDocument(null, ed.Document.FileName); ResolveResult resolveResult = (ResolveResult)item.Item; if (lastResult != null && lastResult.ResolvedExpression != null && lastWindow.IsRealized && resolveResult != null && resolveResult.ResolvedExpression != null && lastResult.ResolvedExpression.Expression == resolveResult.ResolvedExpression.Expression) { return(lastWindow); } LanguageItemWindow result = new LanguageItemWindow(ed, modifierState, resolveResult, null, doc != null ? doc.CompilationUnit : null); lastWindow = result; lastResult = resolveResult; if (result.IsEmpty) { return(null); } return(result); }
void OnFileRemoved(object sender, ProjectFileEventArgs args) { ArrayList toDelete = new ArrayList(); ArrayList toDeleteGroups = new ArrayList(); ParsedDocument doc = ProjectDomService.GetParsedDocument(ProjectDomService.GetProjectDom(args.Project), args.ProjectFile.Name); if (doc == null || doc.CompilationUnit == null) { return; } foreach (IType t in doc.CompilationUnit.Types) { GuiBuilderWindow win = GetWindowForClass(t.FullName); if (win != null) { toDelete.Add(win); continue; } Stetic.ActionGroupInfo group = GetActionGroup(t.FullName); if (group != null) { toDeleteGroups.Add(group); } } foreach (GuiBuilderWindow win in toDelete) { Remove(win); } foreach (Stetic.ActionGroupInfo group in toDeleteGroups) { RemoveActionGroup(group); } }
// public bool RenameVariable (IProgressMonitor monitor, LocalVariable var, string newName) // { // try { // MemberReferenceCollection refs = new MemberReferenceCollection (); // Refactor (monitor, var, new RefactorDelegate (new RefactorFindVariableReferences (var, refs).Refactor)); // refs.RenameAll (newName); // // RefactorerContext gctx = GetGeneratorContext (var); // IRefactorer r = GetGeneratorForVariable (var); // bool rv = r.RenameVariable (gctx, var, newName); // gctx.Save (); // // return rv; // } catch (Exception e) { // LoggingService.LogError (GettextCatalog.GetString ("Error while renaming {0} to {1}: {2}", var, newName, e.ToString ())); // return false; // } // } // // public bool RenameParameter (IProgressMonitor monitor, IParameter param, string newName) // { // try { // MemberReferenceCollection refs = new MemberReferenceCollection (); // Refactor (monitor, param, new RefactorDelegate (new RefactorFindParameterReferences (param, refs, false).Refactor)); // refs.RenameAll (newName); // // IMember member = param.DeclaringMember; // RefactorerContext gctx = GetGeneratorContext (member.DeclaringType); // IRefactorer r = GetGeneratorForClass (member.DeclaringType); // bool rv = r.RenameParameter (gctx, param, newName); // gctx.Save (); // // return rv; // } catch (Exception e) { // LoggingService.LogError (GettextCatalog.GetString ("Error while renaming {0} to {1}: {2}", param, newName, e.ToString ())); // return false; // } // } public IType[] FindDerivedClasses(IType baseClass) { ArrayList list = new ArrayList(); if (solution != null) { foreach (Project p in solution.GetAllProjects()) { ProjectDom ctx = ProjectDomService.GetProjectDom(p); if (ctx == null) { continue; } foreach (IType cls in ctx.Types) { if (IsSubclass(ctx, baseClass, cls)) { list.Add(cls); } } } } else { ProjectDom ctx = GetParserContext(baseClass); if (ctx != null) { foreach (IType cls in ctx.Types) { if (IsSubclass(ctx, baseClass, cls)) { list.Add(cls); } } } } return((IType[])list.ToArray(typeof(IType))); }
void ParseCallback(object ob, IProgressMonitor monitor) { string fileName = (string)ob; ProjectDomService.Parse(Project, fileName, null, delegate() { return(File.ReadAllText(fileName)); }); /* * ParseFile (fileName, monitor); * lock (rwlock) { * FileEntry file = GetFile (fileName); * if (file != null) { * file.InParseQueue = false; * FileInfo fi = new FileInfo (fileName); * file.LastParseTime = fi.LastWriteTime; * } * }*/ }
public CodeTemplateContext GetTemplateContext() { if (IsSomethingSelected) { string fileName = view.ContentName ?? view.UntitledName; IParser parser = ProjectDomService.GetParser(fileName, Document.MimeType); if (parser == null) { return(CodeTemplateContext.Standard); } IExpressionFinder expressionFinder = parser.CreateExpressionFinder(ProjectDom); if (expressionFinder == null) { return(CodeTemplateContext.Standard); } if (expressionFinder.IsExpression(Document.GetTextAt(SelectionRange))) { return(CodeTemplateContext.InExpression); } } return(CodeTemplateContext.Standard); }
void OnDocumentChanged(object o, EventArgs a) { // Don't directly parse the document because doing it at every key press is // very inefficient. Do it after a small delay instead, so several changes can // be parsed at the same time. if (parsing) { return; } parsing = true; string currentParseFile = FileName; string mime = DesktopService.GetMimeTypeForUri(currentParseFile); GLib.Timeout.Add(ParseDelay, delegate { if (closed) { return(false); } parsing = false; string currentParseText = TextEditor.Text; Project curentParseProject = Project; System.Threading.ThreadPool.QueueUserWorkItem(delegate { // Don't access Document properties from the thread this.parsedDocument = ProjectDomService.Parse(curentParseProject, currentParseFile, mime, currentParseText); if (this.parsedDocument != null && !this.parsedDocument.HasErrors) { this.lastErrorFreeParsedDocument = parsedDocument; } DispatchService.GuiSyncDispatch(delegate { OnDocumentParsed(EventArgs.Empty); }); }); return(false); }); }
void LoadExceptions() { ProjectDom dom; if (IdeApp.ProjectOperations.CurrentSelectedProject != null) { dom = ProjectDomService.GetProjectDom(IdeApp.ProjectOperations.CurrentSelectedProject); } else { string asm = typeof(Uri).Assembly.Location; if (!systemLoaded) { ProjectDomService.LoadAssembly(Runtime.SystemAssemblyService.CurrentRuntime, asm); systemLoaded = true; } dom = ProjectDomService.GetAssemblyDom(Runtime.SystemAssemblyService.CurrentRuntime, asm); } classes.Add("System.Exception"); foreach (IType t in dom.GetSubclasses(dom.GetType("System.Exception", true))) { classes.Add(t.FullName); } }
public static void AddNewMember(IType type, IMember newMember, bool implementExplicit = false) { bool isOpen; var data = TextFileProvider.Instance.GetTextEditorData(type.CompilationUnit.FileName, out isOpen); var parsedDocument = ProjectDomService.GetParsedDocument(type.SourceProjectDom, type.CompilationUnit.FileName); var insertionPoints = GetInsertionPoints(data, parsedDocument, type); var suitableInsertionPoint = GetSuitableInsertionPoint(insertionPoints, type, newMember); var generator = CreateCodeGenerator(data); var generatedCode = generator.CreateMemberImplementation(type, newMember, implementExplicit); suitableInsertionPoint.Insert(data, generatedCode.Code); if (!isOpen) { try { File.WriteAllText(type.CompilationUnit.FileName, data.Text); } catch (Exception e) { LoggingService.LogError(GettextCatalog.GetString("Failed to write file '{0}'.", type.CompilationUnit.FileName), e); MessageService.ShowError(GettextCatalog.GetString("Failed to write file '{0}'.", type.CompilationUnit.FileName)); } } }
ITypeNameResolver GetTypeNameResolver(IType cls) { if (cls.CompilationUnit == null || cls.CompilationUnit.FileName == FilePath.Null) { return(null); } string file = cls.CompilationUnit.FileName; ParsedDocument pi = ProjectDomService.GetParsedDocument(cls.SourceProjectDom, file); if (pi == null) { return(null); } ICompilationUnit unit = pi.CompilationUnit; if (unit != null) { return(new TypeNameResolver(unit, cls)); } else { return(null); } }
// string expression; /* IMember GetLanguageItem (Mono.TextEditor.Document document, LineSegment line, int offset, string expression) * { * string txt = document.Text; * ExpressionResult expressionResult = new ExpressionResult (expression); * // ExpressionResult expressionResult = expressionFinder.FindFullExpression (txt, offset); * int lineNumber = document.OffsetToLineNumber (offset); * expressionResult.Region = new DomRegion (lineNumber, offset - line.Offset, lineNumber, offset + expression.Length - line.Offset); * expressionResult.ExpressionContext = ExpressionContext.IdentifierExpected; * * resolver = new NRefactoryResolver (ctx, doc.CompilationUnit, doc.TextEditor, document.FileName); * ResolveResult result = resolver.Resolve (expressionResult, expressionResult.Region.Start); * * if (result is MemberResolveResult) * return ((MemberResolveResult)result).ResolvedMember; * return null; * }*/ public override void Analyze(Mono.TextEditor.Document doc, LineSegment line, Chunk startChunk, int startOffset, int endOffset) { if (!MonoDevelop.Core.PropertyService.Get("EnableSemanticHighlighting", false) || doc == null || line == null || startChunk == null) { return; } ctx = GetParserContext(doc); int lineNumber = doc.OffsetToLineNumber(line.Offset); ParsedDocument parsedDocument = ProjectDomService.GetParsedDocument(ctx, doc.FileName); ICompilationUnit unit = parsedDocument != null ? parsedDocument.CompilationUnit : null; if (unit == null) { return; } for (Chunk chunk = startChunk; chunk != null; chunk = chunk.Next) { if (chunk.Style != "text") { continue; } for (int i = chunk.Offset; i < chunk.EndOffset; i++) { char charBefore = i > 0 ? doc.GetCharAt(i - 1) : '}'; if (Char.IsLetter(doc.GetCharAt(i)) && !Char.IsLetterOrDigit(charBefore)) { } else { continue; } int start = i; bool wasWhitespace = false; bool wasDot = false; int bracketCount = 0; while (start > 0) { char ch = doc.GetCharAt(start); if (ch == '\n' || ch == '\r') { break; } if (wasWhitespace && IsNamePart(ch)) { start++; if (start < chunk.Offset) { start = Int32.MaxValue; } break; } if (ch == '<') { bracketCount--; if (bracketCount < 0) { start++; break; } start--; wasWhitespace = false; continue; } if (ch == '>') { if (wasWhitespace && !wasDot) { break; } bracketCount++; start--; wasWhitespace = false; continue; } if (!IsNamePart(ch) && !Char.IsWhiteSpace(ch) && ch != '.') { start++; break; } wasWhitespace = Char.IsWhiteSpace(ch); wasDot = ch == '.' || wasDot && wasWhitespace; start--; } int end = i; int genericCount = 0; wasWhitespace = false; List <Segment> nameSegments = new List <Segment> (); while (end < chunk.EndOffset) { char ch = doc.GetCharAt(end); if (wasWhitespace && IsNamePart(ch)) { break; } if (ch == '<') { genericCount = 1; while (end < doc.Length) { ch = doc.GetCharAt(end); if (ch == ',') { genericCount++; } if (ch == '>') { nameSegments.Add(new Segment(end, 1)); break; } end++; } break; } if (!IsNamePart(ch) && !Char.IsWhiteSpace(ch)) { break; } wasWhitespace = Char.IsWhiteSpace(ch); end++; } if (start >= end) { continue; } string typeString = doc.GetTextBetween(start, end); IReturnType returnType = NRefactoryResolver.ParseReturnType(new ExpressionResult(typeString)); int nameEndOffset = start; for (; nameEndOffset < end; nameEndOffset++) { char ch = doc.GetCharAt(nameEndOffset); if (nameEndOffset >= i && ch == '<') { nameEndOffset++; break; } } nameSegments.Add(new Segment(i, nameEndOffset - i)); int column = i - line.Offset; IType callingType = unit.GetTypeAt(lineNumber, column); List <IReturnType> genericParams = null; if (genericCount > 0) { genericParams = new List <IReturnType> (); for (int n = 0; n < genericCount; n++) { genericParams.Add(new DomReturnType("A")); } } IType type = null; if (ctx != null) { type = ctx.SearchType((MonoDevelop.Projects.Dom.INode)callingType ?? unit, returnType); } if (type == null && unit != null && returnType != null) { type = unit.GetType(returnType.FullName, returnType.GenericArguments.Count); } if (ctx != null && type == null && returnType != null) { returnType.Name += "Attribute"; type = ctx.SearchType((MonoDevelop.Projects.Dom.INode)callingType ?? unit, returnType); } if (type != null) { nameSegments.ForEach(segment => HighlightSegment(startChunk, segment, "keyword.semantic.type")); } } } }