public GenerateNamespaceImport GetResult (ProjectDom dom, ICompilationUnit unit, IType type, TextEditorData data) { GenerateNamespaceImport result; if (cache.TryGetValue (type.Namespace, out result)) return result; result = new GenerateNamespaceImport (); cache[type.Namespace] = result; result.InsertNamespace = false; DomLocation location = new DomLocation (data.Caret.Line, data.Caret.Column); foreach (IUsing u in unit.Usings.Where (u => u.ValidRegion.Contains (location))) { if (u.Namespaces.Any (ns => type.Namespace == ns)) { result.GenerateUsing = false; return result; } } result.GenerateUsing = true; string name = type.DecoratedFullName.Substring (type.Namespace.Length + 1); foreach (IUsing u in unit.Usings.Where (u => u.ValidRegion.Contains (location))) { foreach (string ns in u.Namespaces) { if (dom.SearchType (unit, unit.GetTypeAt (location), unit.GetMemberAt (location), ns + "." + name) != null) { result.GenerateUsing = false; result.InsertNamespace = true; return result; } } } return result; }
public static void Format (TextEditorData data, ProjectDom dom, DomLocation location, bool correctBlankLines) { PolicyContainer policyParent = dom != null && dom.Project != null? dom.Project.Policies : PolicyService.DefaultPolicies; var mimeTypeChain = DesktopService.GetMimeTypeInheritanceChain (CSharpFormatter.MimeType); Format (policyParent, mimeTypeChain, data, dom, location, correctBlankLines); }
public static void Format (MonoDevelop.Ide.Gui.Document data, ProjectDom dom, DomLocation location, bool correctBlankLines, bool runAferCR = false) { PolicyContainer policyParent = dom != null && dom.Project != null ? dom.Project.Policies : PolicyService.DefaultPolicies; var mimeTypeChain = DesktopService.GetMimeTypeInheritanceChain (CSharpFormatter.MimeType); Format (policyParent, mimeTypeChain, data, dom, location, correctBlankLines, runAferCR); }
public RefactorerContext (ProjectDom ctx, ITextFileProvider files, IType cls) { this.files = files; this.ctx = ctx; if (cls != null) typeResolver = GetTypeNameResolver (cls); }
public override ParsedDocument Parse (ProjectDom dom, string fileName, string fileContent) { XmlParsedDocument doc = new XmlParsedDocument (fileName); doc.Flags |= ParsedDocumentFlags.NonSerializable; TextReader tr = new StringReader (fileContent); try { Parser xmlParser = new Parser (new XmlFreeState (), true); xmlParser.Parse (tr); doc.XDocument = xmlParser.Nodes.GetRoot (); doc.Add (xmlParser.Errors); if (doc.XDocument != null && doc.XDocument.RootElement != null) { if (!doc.XDocument.RootElement.IsEnded) doc.XDocument.RootElement.End (xmlParser.Location); } } catch (Exception ex) { MonoDevelop.Core.LoggingService.LogError ("Unhandled error parsing xml document", ex); } finally { if (tr != null) tr.Dispose (); } return doc; }
public override IEnumerable<MemberReference> FindReferences (ProjectDom dom, FilePath fileName, IEnumerable<INode> searchedMembers) { var editor = TextFileProvider.Instance.GetTextEditorData (fileName); AspNetAppProject project = dom.Project as AspNetAppProject; if (project == null) yield break; var unit = AspNetParserService.GetCompileUnit (project, fileName, true); if (unit == null) yield break; var refman = new DocumentReferenceManager (project); var parsedAspDocument = (AspNetParsedDocument)new AspNetParser ().Parse (dom, fileName, editor.Text); refman.Doc = parsedAspDocument; var usings = refman.GetUsings (); var documentInfo = new DocumentInfo (dom, unit, usings, refman.GetDoms ()); var builder = new AspLanguageBuilder (); var buildDocument = new Mono.TextEditor.Document (); var offsetInfos = new List<LocalDocumentInfo.OffsetInfo> (); buildDocument.Text = builder.BuildDocumentString (documentInfo, editor, offsetInfos, true); var parsedDocument = AspLanguageBuilder.Parse (dom, fileName, buildDocument.Text); foreach (var member in searchedMembers) { foreach (var reference in SearchMember (member, dom, fileName, editor, buildDocument, offsetInfos, parsedDocument)) { yield return reference; } } }
public InstantiatedParameterType (ProjectDom dom, ITypeParameterMember typeParameterMember, ITypeParameter tp) { IType outerType = typeParameterMember as IType ?? typeParameterMember.DeclaringType; typeparam = tp; compilationUnit = outerType.CompilationUnit; ClassType = ClassType.Class; Modifiers = Modifiers.Public; Name = tp.Name; Namespace = outerType.DecoratedFullName; Location = outerType.Location; DeclaringType = outerType; if (tp.Constraints.Count > 0) ClassType = ClassType.Interface; foreach (IReturnType rt in tp.Constraints) { if (FindCyclicReference (new HashSet<ITypeParameter> () { tp }, outerType, ((DomReturnType)rt).DecoratedFullName)) continue; IType bt = dom.SearchType (typeParameterMember, rt); IReturnType resolvedType = rt; if (bt != null) { resolvedType = new DomReturnType (bt); if (bt.ClassType == ClassType.Interface || BaseType != null) { AddInterfaceImplementation (resolvedType); } else { ClassType = bt.ClassType; BaseType = resolvedType; } } else { AddInterfaceImplementation (resolvedType); } } if (BaseType == null) BaseType = DomReturnType.Object; }
public override IEnumerable<MemberReference> FindReferences (ProjectDom dom, FilePath fileName, IEnumerable<INode> searchedMembers) { HashSet<int > positions = new HashSet<int> (); var editor = TextFileProvider.Instance.GetTextEditorData (fileName); FindMemberAstVisitor visitor = new FindMemberAstVisitor (editor.Document); visitor.IncludeXmlDocumentation = IncludeDocumentation; visitor.Init (searchedMembers); if (!visitor.FileContainsMemberName ()) { yield break; } var doc = ProjectDomService.ParseFile (dom, fileName, () => editor.Text); if (doc == null || doc.CompilationUnit == null) yield break; var resolver = new NRefactoryResolver (dom, doc.CompilationUnit, ICSharpCode.NRefactory.SupportedLanguage.CSharp, editor, fileName); visitor.ParseFile (resolver); visitor.RunVisitor (resolver); foreach (var reference in visitor.FoundReferences) { if (positions.Contains (reference.Position)) continue; positions.Add (reference.Position); yield return reference; } visitor.ClearParsers (); }
public override ParsedDocument Parse (ProjectDom dom, string fileName, string fileContent) { XmlParsedDocument doc = new XmlParsedDocument (fileName); doc.Flags = ParsedDocumentFlags.NonSerializable; TextReader tr = new StringReader (fileContent); try { Parser xmlParser = new Parser ( new XmlFreeState (new HtmlTagState (true), new HtmlClosingTagState (true)), true); xmlParser.Parse (tr); doc.XDocument = xmlParser.Nodes.GetRoot (); doc.Add (xmlParser.Errors); if (doc.XDocument != null) doc.Add (Validate (doc.XDocument)); } catch (Exception ex) { MonoDevelop.Core.LoggingService.LogError ("Unhandled error parsing HTML document", ex); } finally { if (tr != null) tr.Dispose (); } return doc; }
public static IMember GetCompatibleMemberInClass (ProjectDom ctx, IType cls, CodeTypeMember member) { //check for identical property names foreach (IProperty prop in cls.Properties) { if (string.Compare (prop.Name, member.Name, StringComparison.OrdinalIgnoreCase) == 0) { EnsureClassExists (ctx, prop.ReturnType.FullName, GetValidRegion (prop)); CodeMemberProperty memProp = member as CodeMemberProperty; if (memProp == null || !IsTypeCompatible (ctx, prop.ReturnType.FullName, memProp.Type.BaseType)) throw new MemberExistsException (cls.FullName, MemberType.Property, member, GetValidRegion (prop), cls.CompilationUnit.FileName); return prop; } } //check for identical method names foreach (IMethod meth in cls.Methods) { if (string.Compare (meth.Name, member.Name, StringComparison.OrdinalIgnoreCase) == 0) { EnsureClassExists (ctx, meth.ReturnType.FullName, GetValidRegion (meth)); CodeMemberMethod memMeth = member as CodeMemberMethod; if (memMeth == null || !IsTypeCompatible (ctx, meth.ReturnType.FullName, memMeth.ReturnType.BaseType)) throw new MemberExistsException (cls.FullName, MemberType.Method, member, GetValidRegion (meth), cls.CompilationUnit.FileName); return meth; } } //check for identical event names foreach (IEvent ev in cls.Events) { if (string.Compare (ev.Name, member.Name, StringComparison.OrdinalIgnoreCase) == 0) { EnsureClassExists (ctx, ev.ReturnType.FullName, GetValidRegion (ev)); CodeMemberEvent memEv = member as CodeMemberEvent; if (memEv == null || !IsTypeCompatible (ctx, ev.ReturnType.FullName, memEv.Type.BaseType)) throw new MemberExistsException (cls.FullName, MemberType.Event, member, GetValidRegion (ev), cls.CompilationUnit.FileName); return ev; } } //check for identical field names foreach (IField field in cls.Fields) { if (string.Compare (field.Name, member.Name, StringComparison.OrdinalIgnoreCase) == 0) { EnsureClassExists (ctx, field.ReturnType.FullName, GetValidRegion (field)); CodeMemberField memField = member as CodeMemberField; if (memField == null || !IsTypeCompatible (ctx, field.ReturnType.FullName, memField.Type.BaseType)) throw new MemberExistsException (cls.FullName, MemberType.Field, member, GetValidRegion (field), cls.CompilationUnit.FileName); return field; } } //walk down into base classes, if any foreach (IReturnType baseType in cls.BaseTypes) { IType c = ctx.GetType (baseType); if (c == null) throw new TypeNotFoundException (baseType.FullName, cls.BodyRegion, cls.CompilationUnit.FileName); IMember mem = GetCompatibleMemberInClass (ctx, c, member); if (mem != null) return mem; } //return null if no match return null; }
public override IEnumerable<MemberReference> FindReferences (ProjectDom dom, FilePath fileName, IEnumerable<INode> searchedMembers) { foreach (var member in searchedMembers) { foreach (var reference in FindReferences (dom, fileName, member)) { yield return reference; } } }
public static ParsedDocument Parse (ProjectDom dom, string fileName, string text) { var result = new MonoDevelop.CSharp.Parser.McsParser ().Parse (null, fileName, text); foreach (DomType type in result.CompilationUnit.Types) { type.SourceProjectDom = dom; } return result; }
public override IResolver CreateResolver (ProjectDom dom, object editor, string fileName) { MonoDevelop.Ide.Gui.Document doc = (MonoDevelop.Ide.Gui.Document)editor; if (doc.Editor == null) return null; return new NRefactoryResolver (dom, doc.CompilationUnit, ICSharpCode.OldNRefactory.SupportedLanguage.CSharp, doc.Editor, fileName); }
public string OutputNode (ProjectDom dom, INode node, string indent) { CSharpOutputVisitor outputVisitor = new CSharpOutputVisitor (); CSharpFormatter.SetFormatOptions (outputVisitor, dom != null && dom.Project != null ? dom.Project.Policies : null); int col = CSharpFormatter.GetColumn (indent, 0, 4); outputVisitor.OutputFormatter.IndentationLevel = System.Math.Max (0, col / 4); node.AcceptVisitor (outputVisitor, null); return outputVisitor.Text; }
IType GetFullClass (out ProjectDom ctx) { if (project == null || className == null) { ctx = null; return null; } ctx = MonoDevelop.Projects.Dom.Parser.ProjectDomService.GetProjectDom (project); return ctx.GetType (className, false, false); }
public override void Initialize () { base.Initialize (); dom = Document.Dom; textEditorResolver = base.Document.GetContent<ITextEditorResolver> (); textEditorData = base.Document.Editor; textEditorData.Caret.PositionChanged += HandleTextEditorDataCaretPositionChanged; textEditorData.Document.TextReplaced += HandleTextEditorDataDocumentTextReplaced; }
public override void Initialize () { base.Initialize (); dom = Document.Dom; textEditorData = Document.TextEditorData; InitTracker (); IEnumerable<string> types = MonoDevelop.Ide.DesktopService.GetMimeTypeInheritanceChain (CSharpFormatter.MimeType); if (dom != null && dom.Project != null) policy = base.Document.Project.Policies.Get<CSharpFormattingPolicy> (types); }
public string OutputNode(ProjectDom dom, INode node, string indent) { /* WNH FSharpOutputVisitor FIXME!!!!! FSharpOutputVisitor outputVisitor = new FSharpOutputVisitor (); FSharpFormatter.SetFormatOptions (outputVisitor, dom.Project); int col = FSharpFormatter.GetColumn (indent, 0, 4); outputVisitor.OutputFormatter.IndentationLevel = System.Math.Max (0, col / 4); node.AcceptVisitor (outputVisitor, null); return outputVisitor.Text; WNH */ return "Hello World"; // WNH RIP OUT later }
static IEnumerable <MonoDevelop.Projects.Dom.IProperty> GetAllProperties( MonoDevelop.Projects.Dom.Parser.ProjectDom projectDatabase, MonoDevelop.Projects.Dom.IType cls) { foreach (MonoDevelop.Projects.Dom.IType type in projectDatabase.GetInheritanceTree(cls)) { foreach (MonoDevelop.Projects.Dom.IProperty prop in type.Properties) { yield return(prop); } } }
static IEnumerable <MonoDevelop.Projects.Dom.IEvent> GetAllEvents( MonoDevelop.Projects.Dom.Parser.ProjectDom projectDatabase, MonoDevelop.Projects.Dom.IType cls) { foreach (MonoDevelop.Projects.Dom.IType type in projectDatabase.GetInheritanceTree(cls)) { foreach (MonoDevelop.Projects.Dom.IEvent ev in type.Events) { yield return(ev); } } }
public NewOverrideCompletionData (ProjectDom dom, TextEditorData editor, int declarationBegin, IType type, IMember member) : base (null) { this.editor = editor; this.type = type; this.member = member; this.declarationBegin = declarationBegin; this.GenerateBody = true; this.Icon = member.StockIcon; this.DisplayText = ambience.GetString (member, OutputFlags.IncludeParameters | OutputFlags.IncludeGenerics | OutputFlags.HideExtensionsParameter); this.CompletionText = member.Name; }
static IEnumerable<Tuple<ProjectDom, FilePath>> GetFileNames (Solution solution, ProjectDom dom, ICompilationUnit unit, INode member, IProgressMonitor monitor) { var scope = GetScope (member); int counter = 0; switch (scope) { case RefactoryScope.File: case RefactoryScope.DeclaringType: if (dom != null && unit != null) yield return Tuple.Create (dom, unit.FileName); break; case RefactoryScope.Project: if (dom == null) yield break; if (monitor != null) monitor.BeginTask (GettextCatalog.GetString ("Finding references in project..."), dom.Project.Files.Count); foreach (var file in dom.Project.Files) { if (monitor != null && monitor.IsCancelRequested) yield break; yield return Tuple.Create (dom, file.FilePath); if (monitor != null) { if (counter % 10 == 0) monitor.Step (10); counter++; } } if (monitor != null) monitor.EndTask (); break; case RefactoryScope.Solution: var allProjects = solution.GetAllProjects (); if (monitor != null) monitor.BeginTask (GettextCatalog.GetString ("Finding references in solution..."), allProjects.Sum (p => p.Files.Count)); foreach (var project in allProjects) { if (monitor != null && monitor.IsCancelRequested) yield break; var currentDom = ProjectDomService.GetProjectDom (project); foreach (var file in project.Files) { if (monitor != null && monitor.IsCancelRequested) yield break; yield return Tuple.Create (currentDom, file.FilePath); if (monitor != null) { if (counter % 10 == 0) monitor.Step (10); counter++; } } } if (monitor != null) monitor.EndTask (); break; } }
public string OutputNode (ProjectDom dom, AstNode node, string indent) { StringWriter w = new StringWriter(); var policyParent = dom != null && dom.Project != null ? dom.Project.Policies : null; IEnumerable<string> types = DesktopService.GetMimeTypeInheritanceChain (CSharpFormatter.MimeType); CSharpFormattingPolicy codePolicy = policyParent != null ? policyParent.Get<CSharpFormattingPolicy> (types) : MonoDevelop.Projects.Policies.PolicyService.GetDefaultPolicy<CSharpFormattingPolicy> (types); var formatter = new TextWriterOutputFormatter(w); int col = GetColumn (indent, 0, 4); formatter.Indentation = System.Math.Max (0, col / 4); OutputVisitor visitor = new OutputVisitor (formatter, codePolicy.CreateOptions ()); node.AcceptVisitor (visitor, null); return w.ToString(); }
public void Deserialize(XElement xml, ProjectDom dom) { if (xml == null) { throw new ArgumentNullException ("xml"); } var textAttr = xml.Attribute ("CommentText"); if (textAttr != null) { Text = textAttr.Value; } this.DeserializePosition (xml.Element ("Position")); }
public override ParsedDocument Parse (ProjectDom dom, string fileName, string fileContent) { using (var tr = new StringReader (fileContent)) { var info = new PageInfo (); var rootNode = new RootNode (); var errors = new List<Error> (); try { rootNode.Parse (fileName, tr); } catch (Exception ex) { LoggingService.LogError ("Unhandled error parsing ASP.NET document '" + (fileName ?? "") + "'", ex); errors.Add (new Error (ErrorType.Error, 0, 0, "Unhandled error parsing ASP.NET document: " + ex.Message)); } foreach (var pe in rootNode.ParseErrors) errors.Add (new Error (ErrorType.Error, pe.Location.BeginLine, pe.Location.BeginColumn, pe.Message)); info.Populate (rootNode, errors); var type = AspNetAppProject.DetermineWebSubtype (fileName); if (type != info.Subtype) { if (info.Subtype == WebSubtype.None) { errors.Add (new Error (ErrorType.Error, 1, 1, "File directive is missing")); } else { type = info.Subtype; errors.Add (new Error (ErrorType.Warning, 1, 1, "File directive does not match page extension")); } } var result = new AspNetParsedDocument (fileName, type, rootNode, info); result.Add (errors); /* if (MonoDevelop.Core.LoggingService.IsLevelEnabled (MonoDevelop.Core.Logging.LogLevel.Debug)) { DebugStringVisitor dbg = new DebugStringVisitor (); rootNode.AcceptVisit (dbg); System.Text.StringBuilder sb = new System.Text.StringBuilder (); sb.AppendLine ("Parsed AspNet file:"); sb.AppendLine (dbg.DebugString); if (errors.Count > 0) { sb.AppendLine ("Errors:"); foreach (ParserException ex in errors) sb.AppendLine (ex.ToString ()); } MonoDevelop.Core.LoggingService.LogDebug (sb.ToString ()); }*/ return result; } }
public override void Initialize () { base.Initialize (); dom = Document.Dom; textEditorData = Document.Editor; IEnumerable<string > types = MonoDevelop.Ide.DesktopService.GetMimeTypeInheritanceChain (CSharpFormatter.MimeType); if (dom != null && dom.Project != null) policy = dom.Project.Policies.Get<CSharpFormattingPolicy> (types); InitTracker (); UpdatePath (null, null); textEditorData.Caret.PositionChanged += UpdatePath; Document.DocumentParsed += HandleDocumentDocumentParsed; }
IEnumerable<MemberReference> FindReferences (ProjectDom dom, FilePath fileName, INode member) { var editor = TextFileProvider.Instance.GetTextEditorData (fileName); var doc = ProjectDomService.GetParsedDocument (dom, fileName); if (doc == null || doc.CompilationUnit == null) return null; var resolver = new NRefactoryResolver (dom, doc.CompilationUnit, ICSharpCode.NRefactory.SupportedLanguage.CSharp, editor, fileName); FindMemberAstVisitor visitor = new FindMemberAstVisitor (editor.Document, resolver, member); visitor.IncludeXmlDocumentation = IncludeDocumentation; visitor.RunVisitor (); return visitor.FoundReferences; }
public override bool IsAccessibleFrom(MonoDevelop.Projects.Dom.Parser.ProjectDom dom, IType calledType, IMember member, bool includeProtected) { if (calledType != null) { foreach (IType baseType in dom.GetInheritanceTree(calledType)) { if (baseType.FullName == calledType.FullName) { return(true); } } } return(base.IsAccessibleFrom(dom, calledType, member, includeProtected)); }
static void RemoveParseJobs(ProjectDom dom) { lock (parseQueueLock) { foreach (ParsingJob pj in parseQueue) { if (pj.Database == dom) { pj.ParseCallback = null; parseQueueIndex.Remove(pj.File); } } } }
// Returns the ParsedDocument object for a file. It will parse // the file if it has not been recently parsed public static ParsedDocument GetParsedDocument(ProjectDom dom, string fileName) { if (fileName == null || fileName.Length == 0) { return(null); } ParsedDocument info = GetCachedParseInformation(fileName); if (info != null) { return(info); } return(ParseFile(dom, fileName)); }
public static ProjectDom GetFileDom(FilePath file) { if (file.IsNull) { file = Path.GetTempFileName(); } file = file.CanonicalPath; lock (singleDatabases) { SingleFileCacheEntry entry; if (singleDatabases.TryGetValue(file, out entry)) { entry.AccessTime = DateTime.Now; return(entry.Database); } else { if (singleDatabases.Count >= MAX_SINGLEDB_CACHE_SIZE) { DateTime tim = DateTime.MaxValue; string toDelete = null; foreach (KeyValuePair <FilePath, SingleFileCacheEntry> pce in singleDatabases) { DateTime ptim = pce.Value.AccessTime; if (ptim < tim) { tim = ptim; toDelete = pce.Key; } } singleDatabases.Remove(toDelete); } ProjectDom db = ParserDatabase.LoadSingleFileDom(file); db.Uri = "File:" + file; db.UpdateReferences(); entry = new SingleFileCacheEntry(); entry.Database = db; entry.AccessTime = DateTime.Now; singleDatabases [file] = entry; db.ReferenceCount = 1; return(db); } } }
public RefactoringPreviewDialog (ProjectDom ctx, List<Change> changes) { this.Build (); this.changes = changes; treeviewPreview.Model = store; TreeViewColumn column = new TreeViewColumn (); // pixbuf column var pixbufCellRenderer = new CellRendererPixbuf (); column.PackStart (pixbufCellRenderer, false); column.SetAttributes (pixbufCellRenderer, "pixbuf", pixbufColumn); column.AddAttribute (pixbufCellRenderer, "visible", statusVisibleColumn); // text column CellRendererText cellRendererText = new CellRendererText (); column.PackStart (cellRendererText, false); column.SetAttributes (cellRendererText, "text", textColumn); column.AddAttribute (cellRendererText, "visible", statusVisibleColumn); // location column CellRendererText cellRendererText2 = new CellRendererText (); column.PackStart (cellRendererText2, false); column.SetCellDataFunc (cellRendererText2, new TreeCellDataFunc (SetLocationTextData)); CellRendererDiff cellRendererDiff = new CellRendererDiff (); column.PackStart (cellRendererDiff, true); column.SetCellDataFunc (cellRendererDiff, new TreeCellDataFunc (SetDiffCellData)); treeviewPreview.AppendColumn (column); treeviewPreview.HeadersVisible = false; buttonCancel.Clicked += delegate { Destroy (); }; buttonOk.Clicked += delegate { IProgressMonitor monitor = IdeApp.Workbench.ProgressMonitors.GetBackgroundProgressMonitor (this.Title, null); RefactoringService.AcceptChanges (monitor, ctx, changes); Destroy (); }; FillChanges (); Resize (IdeApp.Workbench.ActiveDocument.ActiveView.Control.Allocation.Width, IdeApp.Workbench.ActiveDocument.ActiveView.Control.Allocation.Height); }
IEnumerable<MemberReference> SearchMember (INode member, ProjectDom dom, FilePath fileName, Mono.TextEditor.TextEditorData editor, Mono.TextEditor.Document buildDocument, List<LocalDocumentInfo.OffsetInfo> offsetInfos, ParsedDocument parsedDocument) { var resolver = new NRefactoryResolver (dom, parsedDocument.CompilationUnit, ICSharpCode.NRefactory.SupportedLanguage.CSharp, editor, fileName); FindMemberAstVisitor visitor = new FindMemberAstVisitor (buildDocument, member); visitor.IncludeXmlDocumentation = IncludeDocumentation; visitor.RunVisitor (resolver); foreach (var result in visitor.FoundReferences) { var offsetInfo = offsetInfos.FirstOrDefault (info => info.ToOffset <= result.Position && result.Position < info.ToOffset + info.Length); if (offsetInfo == null) continue; var offset = offsetInfo.FromOffset + result.Position - offsetInfo.ToOffset; var loc = editor.OffsetToLocation (offset); yield return new MemberReference (null, fileName, offset, loc.Line, loc.Column, result.Name, null); } }
public override ParsedDocument Parse (ProjectDom dom, string fileName, string content) { ParsedTemplate template = new ParsedTemplate (fileName); try { Tokeniser tk = new Tokeniser (fileName, content); template.ParseWithoutIncludes (tk); } catch (ParserException ex) { template.LogError (ex.Message, ex.Location); } T4ParsedDocument doc = new T4ParsedDocument (fileName, template.RawSegments); doc.Flags |= ParsedDocumentFlags.NonSerializable; foreach (System.CodeDom.Compiler.CompilerError err in template.Errors) doc.Errors.Add (new Error (err.IsWarning? ErrorType.Warning : ErrorType.Error, err.Line, err.Column, err.ErrorText)); return doc; }
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); }
public static void Format (TextEditorData data, ProjectDom dom) { CSharp.Dom.CompilationUnit compilationUnit = new MonoDevelop.CSharp.Parser.CSharpParser ().Parse (data); IEnumerable<string> types = DesktopService.GetMimeTypeInheritanceChain (CSharpFormatter.MimeType); CSharpFormattingPolicy policy = dom.Project.Policies != null ? dom.Project.Policies.Get<CSharpFormattingPolicy> (types) : MonoDevelop.Projects.Policies.PolicyService.GetDefaultPolicy<CSharpFormattingPolicy> (types); DomSpacingVisitor domSpacingVisitor = new DomSpacingVisitor (policy, data); domSpacingVisitor.AutoAcceptChanges = false; compilationUnit.AcceptVisitor (domSpacingVisitor, null); DomIndentationVisitor domIndentationVisitor = new DomIndentationVisitor (policy, data); domIndentationVisitor.AutoAcceptChanges = false; compilationUnit.AcceptVisitor (domIndentationVisitor, null); List<Change> changes = new List<Change> (); changes.AddRange (domSpacingVisitor.Changes); changes.AddRange (domIndentationVisitor.Changes); RefactoringService.AcceptChanges (null, null, changes); }
public static void Load(WorkspaceItem item) { if (IncLoadCount(item) != 1) { return; } lock (databases) { if (item is Workspace) { Workspace ws = (Workspace)item; foreach (WorkspaceItem it in ws.Items) { Load(it); } ws.ItemAdded += OnWorkspaceItemAdded; ws.ItemRemoved += OnWorkspaceItemRemoved; } else if (item is Solution) { Solution solution = (Solution)item; foreach (Project project in solution.GetAllProjects()) { Load(project); } // Refresh the references of all projects. This is necessary because // some project may have been loaded before the projects their reference, // in which case those references are not properly registered. foreach (Project project in solution.GetAllProjects()) { ProjectDom dom = GetProjectDom(project); // referenced by main project - prevents the removal if a project is referenced one time inside the solution // and the project that references it is reloaded. dom.ReferenceCount++; if (dom != null) { dom.UpdateReferences(); } } solution.SolutionItemAdded += OnSolutionItemAdded; solution.SolutionItemRemoved += OnSolutionItemRemoved; } } }
public static void QueueParseJob(ProjectDom db, Action <string, IProgressMonitor> callback, string file) { ParsingJob job = new ParsingJob(); job.ParseCallback = callback; job.File = file; job.Database = db; lock (parseQueueLock) { RemoveParseJob(file); parseQueueIndex [file] = job; parseQueue.Enqueue(job); parseEvent.Set(); if (parseQueueIndex.Count == 1) { queueEmptied.Reset(); } } }
internal static int ResolveTypes(ProjectDom db, ICompilationUnit unit, IEnumerable <IType> types, IEnumerable <IAttribute> attributes, out List <IType> result, out List <IAttribute> resultAtrtibutes) { TypeResolverVisitor tr = new TypeResolverVisitor(db, unit); int unresolvedCount = 0; result = new List <IType> (); foreach (IType c in types) { tr.UnresolvedCount = 0; DomType rc = (DomType)c.AcceptVisitor(tr, null); if (rc.CompilationUnit != null) { rc.CompilationUnit = new CompilationUnit(rc.CompilationUnit.FileName); } rc.Resolved = true; // no need to set the base type here - the completion db handles that // (setting to system.object is wrong for enums & structs - and interfaces may never have a base) /* * if (tr.UnresolvedCount == 0 && c.FullName != "System.Object") { * // If the class has no base classes, make sure it subclasses System.Object * if (rc.BaseType == null) * rc.BaseType = new DomReturnType ("System.Object"); * }*/ result.Add(rc); unresolvedCount += tr.UnresolvedCount; } resultAtrtibutes = new List <IAttribute> (); foreach (IAttribute a in attributes) { tr.UnresolvedCount = 0; DomAttribute ra = (DomAttribute)a.AcceptVisitor(tr, null); resultAtrtibutes.Add(ra); unresolvedCount += tr.UnresolvedCount; } return(unresolvedCount); }
static ParsedDocument DoParseFile(ProjectDom dom, string fileName, string fileContent) { using (Counters.FileParse.BeginTiming()) { IParser parser = GetParser(fileName); if (parser == null) { return(null); } ParsedDocument parserOutput = null; if (fileContent == null) { try { if (!File.Exists(fileName)) { return(null); } using (StreamReader sr = File.OpenText(fileName)) { fileContent = sr.ReadToEnd(); } } catch (Exception e) { LoggingService.LogError("Got exception while reading file", e); return(null); } } parserOutput = parser.Parse(dom, fileName, fileContent); if (parserOutput != null) { AddToCache(parserOutput); OnParsedDocumentUpdated(new ParsedDocumentEventArgs(parserOutput)); } return(parserOutput); } }
public static void Load(Project project) { if (IncLoadCount(project) != 1) { return; } lock (databases) { string uri = "Project:" + project.FileName; if (databases.ContainsKey(uri)) { return; } try { ProjectDom db = ParserDatabase.LoadProjectDom(project); RegisterDom(db, uri); project.Modified += HandleModified; } catch (Exception ex) { LoggingService.LogError("Parser database for project '" + project.Name + " could not be loaded", ex); } } }
public ProjectDomDecorator(ProjectDom decorated) { this.decorated = decorated; }
static ParsedDocument UpdateFile(Project[] projects, string fileName, Func <string> getContent) { try { if (GetParser(fileName) == null) { return(null); } ParsedDocument parseInformation = null; string fileContent; if (getContent == null) { if (!System.IO.File.Exists(fileName)) { fileContent = ""; } else { try { fileContent = System.IO.File.ReadAllText(fileName); } catch (Exception e) { LoggingService.LogError("Error reading file {0} for ProjectDomService: {1}", fileName, e); fileContent = ""; } } } else { fileContent = getContent(); } // Remove any pending jobs for this file RemoveParseJob(fileName); ProjectDom dom = projects != null && projects.Length > 0 ? GetProjectDom(projects [0]) : null; parseInformation = DoParseFile(dom, fileName, fileContent); if (parseInformation == null) { return(null); } // don't update project dom with incorrect parse informations, they may not contain all // information. if (projects != null && projects.Length > 0 && parseInformation.CompilationUnit != null) { SetSourceProject(parseInformation.CompilationUnit, dom); } // if (parseInformation.Errors.Any ()) { // Console.WriteLine (fileName + "-- Errors:"); // foreach (var e in parseInformation.Errors) { // Console.WriteLine (e); // } // } if (parseInformation.CompilationUnit != null && (parseInformation.Flags & ParsedDocumentFlags.NonSerializable) == 0) { if (projects != null && projects.Length > 0) { foreach (Project project in projects) { ProjectDom db = GetProjectDom(project); if (db != null) { try { if (parseInformation.HasErrors) { db.UpdateTemporaryCompilationUnit(parseInformation.CompilationUnit); } else { db.UpdateTagComments(fileName, parseInformation.TagComments); db.RemoveTemporaryCompilationUnit(parseInformation.CompilationUnit); TypeUpdateInformation res = db.UpdateFromParseInfo(parseInformation.CompilationUnit, getContent == null); if (res != null) { NotifyTypeUpdate(project, fileName, res); } UpdatedCommentTasks(fileName, parseInformation.TagComments, project); } } catch (Exception e) { LoggingService.LogError(e.ToString()); } } } } else { ProjectDom db = GetFileDom(fileName); db.UpdateFromParseInfo(parseInformation.CompilationUnit, getContent == null); } } return(parseInformation); } catch (Exception e) { LoggingService.LogError(e.ToString()); return(null); } }
static void CheckModifiedFiles() { // Check databases following a bottom-up strategy in the dependency // tree. This will help resolving parsed classes. Set <ProjectDom> list = new Set <ProjectDom> (); lock (databases) { // There may be several uris for the same db foreach (ProjectDom ob in databases.Values) { list.Add(ob); } } Set <ProjectDom> done = new Set <ProjectDom> (); while (list.Count > 0) { ProjectDom readydb = null; ProjectDom bestdb = null; int bestRefCount = int.MaxValue; // Look for a db with all references resolved foreach (ProjectDom db in list) { bool allDone = true; foreach (ProjectDom refdb in db.References) { if (!done.Contains(refdb)) { allDone = false; break; } } if (allDone) { readydb = db; break; } else if (db.References.Count < bestRefCount) { bestdb = db; bestRefCount = db.References.Count; break; } } // It may not find any db without resolved references if there // are circular dependencies. In this case, take the one with // less references if (readydb == null) { readydb = bestdb; } readydb.CheckModifiedFiles(); list.Remove(readydb); done.Add(readydb); } }
// Parses a file. It does not update the parser database public static ParsedDocument ParseFile(ProjectDom dom, string fileName) { return(ParseFile(dom, fileName, null)); }
// Parses a file. It does not update the parser database public static ParsedDocument ParseFile(ProjectDom dom, string fileName, Func <string> getContent) { string fileContent = getContent != null?getContent() : null; return(DoParseFile(dom, fileName, fileContent)); }
static ParsedDocument UpdateFile(Project[] projects, string fileName, string mimeType, ContentDelegate getContent) { try { if (GetParser(fileName, mimeType) == null) { return(null); } ParsedDocument parseInformation = null; string fileContent; if (getContent == null) { StreamReader sr = new StreamReader(fileName); fileContent = sr.ReadToEnd(); sr.Close(); } else { fileContent = getContent(); } // Remove any pending jobs for this file RemoveParseJob(fileName); ProjectDom dom = projects != null && projects.Length > 0 ? GetProjectDom(projects [0]) : null; parseInformation = DoParseFile(dom, fileName, fileContent); if (parseInformation == null) { return(null); } // don't update project dom with incorrect parse informations, they may not contain all // information. if (projects != null && projects.Length > 0 && parseInformation.CompilationUnit != null) { SetSourceProject(parseInformation.CompilationUnit, dom); } if (parseInformation.CompilationUnit != null && (parseInformation.Flags & ParsedDocumentFlags.NonSerializable) == 0) { if (projects != null && projects.Length > 0) { foreach (Project project in projects) { ProjectDom db = GetProjectDom(project); if (db != null) { try { if (parseInformation.HasErrors) { db.UpdateTemporaryCompilationUnit(parseInformation.CompilationUnit); } else { db.UpdateTagComments(fileName, parseInformation.TagComments); db.RemoveTemporaryCompilationUnit(parseInformation.CompilationUnit); TypeUpdateInformation res = db.UpdateFromParseInfo(parseInformation.CompilationUnit); if (res != null) { NotifyTypeUpdate(project, fileName, res); } UpdatedCommentTasks(fileName, parseInformation.TagComments, project); } } catch (Exception e) { LoggingService.LogError(e.ToString()); } } } } else { ProjectDom db = GetFileDom(fileName); db.UpdateFromParseInfo(parseInformation.CompilationUnit); } } return(parseInformation); } catch (Exception e) { LoggingService.LogError(e.ToString()); return(null); } }
public ProjectDomEventArgs(ProjectDom dom) { this.dom = dom; }
public static void RegisterDom(ProjectDom dom, string uri) { dom.Uri = uri; databases [uri] = dom; dom.UpdateReferences(); }
public TypeResolverVisitor(ProjectDom db, ICompilationUnit unit) { this.db = db; this.unit = unit; }
public virtual ParsedDocument Parse(ProjectDom dom, string fileName, TextReader content) { return(Parse(dom, fileName, content.ReadToEnd())); }
public abstract ParsedDocument Parse(ProjectDom dom, string fileName, string content);
public virtual IResolver CreateResolver(ProjectDom dom, object editor, string fileName) { return(null); }
public virtual IExpressionFinder CreateExpressionFinder(ProjectDom dom) { return(null); }
public ParsedDocument Parse(ProjectDom dom, string fileName) { return(Parse(dom, fileName, System.IO.File.ReadAllText(fileName))); }