public void SetUpFixture() { string ruby = "class Test\r\n" + "\tdef initialize\r\n" + "\t\tputs 'test'\r\n" + "\tend\r\n" + "end"; DefaultProjectContent projectContent = new DefaultProjectContent(); RubyParser parser = new RubyParser(); compilationUnit = parser.Parse(projectContent, @"C:\test.rb", ruby); if (compilationUnit.Classes.Count > 0) { c = compilationUnit.Classes[0]; if (c.Methods.Count > 0) { method = c.Methods[0]; } TextArea textArea = new TextArea(); document = new TextDocument(); textArea.Document = document; textArea.Document.Text = ruby; // Get folds. ParserFoldingStrategy foldingStrategy = new ParserFoldingStrategy(textArea); ParseInformation parseInfo = new ParseInformation(compilationUnit); foldingStrategy.UpdateFoldings(parseInfo); List<FoldingSection> folds = new List<FoldingSection>(foldingStrategy.FoldingManager.AllFoldings); if (folds.Count > 1) { classFold = folds[0]; methodFold = folds[1]; } } }
void ParseStep() { string code = null; Invoke(new MethodInvoker(delegate { code = textEditorControl1.Text; })); TextReader textReader = new StringReader(code); Dom.ICompilationUnit newCompilationUnit; NRefactory.SupportedLanguage supportedLanguage; if (IsVisualBasic) { supportedLanguage = NRefactory.SupportedLanguage.VBNet; } else { supportedLanguage = NRefactory.SupportedLanguage.CSharp; } using (NRefactory.IParser p = NRefactory.ParserFactory.CreateParser(supportedLanguage, textReader)) { // we only need to parse types and method definitions, no method bodies // so speed up the parser and make it more resistent to syntax // errors in methods p.ParseMethodBodies = false; p.Parse(); newCompilationUnit = ConvertCompilationUnit(p.CompilationUnit); } // Remove information from lastCompilationUnit and add information from newCompilationUnit. myProjectContent.UpdateCompilationUnit(lastCompilationUnit, newCompilationUnit, DummyFileName); lastCompilationUnit = newCompilationUnit; parseInformation = new Dom.ParseInformation(newCompilationUnit); }
protected Dom.IMember GetParentMember(ICSharpCode.TextEditor.TextEditorControl textEditor, int line, int column) { Dom.ParseInformation parseInfo = ParserService.GetParseInformation(textEditor.FileName); if (parseInfo != null) { Dom.IClass c = parseInfo.MostRecentCompilationUnit.GetInnermostClass(line, column); if (c != null) { foreach (Dom.IMember member in c.Properties) { if (member.BodyRegion.IsInside(line, column)) { return(member); } } foreach (Dom.IMember member in c.Methods) { if (member.BodyRegion.IsInside(line, column)) { return(member); } } } } return(null); }
public void UpdateFoldings(ParseInformation parseInfo) { IEnumerable<NewFolding> newFoldings = GetNewFoldings(parseInfo); foldingManager.UpdateFoldings(newFoldings, -1); isFirstUpdate = false; }
public void SetUpFixture() { string python = "class Test:\r\n" + "\tdef foo(self):\r\n" + "\t\tpass"; DefaultProjectContent projectContent = new DefaultProjectContent(); PythonParser parser = new PythonParser(); compilationUnit = parser.Parse(projectContent, @"C:\test.py", python); if (compilationUnit.Classes.Count > 0) { c = compilationUnit.Classes[0]; if (c.Methods.Count > 0) { method = c.Methods[0]; } TextArea textArea = new TextArea(); document = new TextDocument(); textArea.Document = document; textArea.Document.Text = python; ParserFoldingStrategy foldingStrategy = new ParserFoldingStrategy(textArea); ParseInformation parseInfo = new ParseInformation(compilationUnit); foldingStrategy.UpdateFoldings(parseInfo); List<FoldingSection> folds = new List<FoldingSection>(foldingStrategy.FoldingManager.AllFoldings); if (folds.Count > 0) { classFold = folds[0]; } if (folds.Count > 1) { methodFold = folds[1]; } } }
public void Constructor_NewInstance_ParseInfoToReturnFromParseFileHasOneClass() { CreateTestableScriptingDesignerGenerator(); parseInfo = generator.CreateParseInfoWithOneClass(); int count = parseInfo.CompilationUnit.Classes.Count; Assert.AreEqual(1, count); }
bool Initialize(ParseInformation parseInfo, int caretLine, int caretColumn) { if (parseInfo == null) { return false; } this.cu = parseInfo.CompilationUnit; if (cu == null) { return false; } this.pc = cu.ProjectContent; this.caretLine = caretLine; this.caretColumn = caretColumn; this.callingClass = GetCallingClass(pc); callingMember = ResolveCurrentMember(callingClass); if (callingMember == null) { if (cu != parseInfo.CompilationUnit) { IClass olderClass = GetCallingClass(parseInfo.CompilationUnit.ProjectContent); if (olderClass != null && callingClass == null) { this.callingClass = olderClass; } callingMember = ResolveCurrentMember(olderClass); } } if (callingMember != null) { if (caretLine > callingMember.BodyRegion.EndLine) { this.caretLine = callingMember.BodyRegion.EndLine; this.caretColumn = callingMember.BodyRegion.EndColumn - 1; } else if (caretLine == callingMember.BodyRegion.EndLine && caretColumn >= callingMember.BodyRegion.EndColumn) { this.caretColumn = callingMember.BodyRegion.EndColumn - 1; } } return true; }
public void Init() { projectContent = new MockProjectContent(); ParseInformation parseInfo = new ParseInformation(new DefaultCompilationUnit(projectContent)); completion = new PythonImportCompletion(projectContent); completionItems = completion.GetCompletionItemsFromModule("sys"); }
ICompilationUnit GetCompilationUnit(ParseInformation parseInfo) { if (parseInfo != null) { return parseInfo.CompilationUnit; } return null; }
public static IList<IClass> FindFormClassParts(ParseInformation parseInfo, out IClass formClass, out bool isFirstClassInFile) { #if DEBUG if ((Control.ModifierKeys & (Keys.Alt | Keys.Control)) == (Keys.Alt | Keys.Control)) { System.Diagnostics.Debugger.Break(); } #endif formClass = null; isFirstClassInFile = true; foreach (IClass c in parseInfo.CompilationUnit.Classes) { if (FormsDesignerSecondaryDisplayBinding.BaseClassIsFormOrControl(c)) { formClass = c; break; } isFirstClassInFile = false; } if (formClass == null) throw new FormsDesignerLoadException("No class derived from Form or UserControl was found."); // Initialize designer for formClass formClass = formClass.GetCompoundClass(); if (formClass is CompoundClass) { return (formClass as CompoundClass).Parts; } else { return new IClass[] { formClass }; } }
public static void Register(MainForm mainForm) { // Must be implemented. Gets the parse information for the specified file. HostCallback.GetParseInformation = delegate(string fileName) { if (fileName != MainForm.DummyFileName) throw new Exception("Unknown file"); if (mainForm.lastCompilationUnit == null) return null; ParseInformation pi = new ParseInformation(); pi.ValidCompilationUnit = mainForm.lastCompilationUnit; return pi; }; // Must be implemented. Gets the project content of the active project. HostCallback.GetCurrentProjectContent = delegate { return mainForm.myProjectContent; }; // The default implementation just logs to Log4Net. We want to display a MessageBox. // Note that we use += here - in this case, we want to keep the default Log4Net implementation. HostCallback.ShowError += delegate(string message, Exception ex) { MessageBox.Show(message + Environment.NewLine + ex.ToString()); }; HostCallback.ShowMessage += delegate(string message) { MessageBox.Show(message); }; HostCallback.ShowAssemblyLoadError += delegate(string fileName, string include, string message) { MessageBox.Show("Error loading code-completion information for " + include + " from " + fileName + ":\r\n" + message + "\r\n"); }; }
public ClassFinder(ParseInformation parseInfo, int caretLineNumber, int caretColumn) { this.caretLine = caretLineNumber; this.caretColumn = caretColumn; Init(parseInfo); }
Variable ResolveVariable(Variable variable) { Dom.ParseInformation info = ParserService.GetParseInformation(this.textEditor.FileName); Dom.ExpressionResult res = new Dom.ExpressionResult(variable.Name, Dom.DomRegion.FromLocation(variable.StartPos, variable.EndPos), Dom.ExpressionContext.Default, null); Dom.ResolveResult result = this.GetResolver().Resolve(res, info, this.textEditor.Document.Text); Dom.IReturnType type = currentProjectContent.SystemTypes.Object; Dom.ClassFinder finder = new Dom.ClassFinder(currentClass, textEditor.Caret.Line, textEditor.Caret.Column); if (result != null && result.ResolvedType != null) { type = result.ResolvedType; } if (variable.Type.Type == "var") { variable.Type = Dom.Refactoring.CodeGenerator.ConvertType(type, finder); } variable.IsReferenceType = type.IsReferenceType == true; return(variable); }
ParseInformation CreateParseInformationWithWebViewPageClass(ParseInformation parseInfo) { RazorCompilationUnit compilationUnit = RazorCompilationUnit.CreateFromParseInfo(parseInfo); AddDefaultUsings(compilationUnit); AddWebViewPageClass(compilationUnit); return new ParseInformation(compilationUnit); }
public ParserUpdateStepEventArgs(string fileName, string content, bool updated, ParseInformation parseInformation) { this.fileName = fileName; this.content = content; this.updated = updated; this.parseInformation = parseInformation; }
public ResolveResult Resolve(ExpressionResult expressionResult, ParseInformation parseInfo, string fileContent) { if (parseInfo == null || (string.IsNullOrEmpty(fileContent) && !(expressionResult.Context is XamlContext))) return null; this.resolveExpression = expressionResult.Expression; this.caretLine = expressionResult.Region.BeginLine; this.caretColumn = expressionResult.Region.BeginColumn; this.callingClass = parseInfo.CompilationUnit.GetInnermostClass(caretLine, caretColumn); this.context = expressionResult.Context as XamlContext ?? CompletionDataHelper.ResolveContext(fileContent, parseInfo.CompilationUnit.FileName, Utils.GetOffsetFromFilePos(fileContent, caretLine, caretColumn)); switch (this.context.Description) { case XamlContextDescription.AtTag: case XamlContextDescription.None: return ResolveElementName(resolveExpression); case XamlContextDescription.InTag: return ResolveAttribute(resolveExpression) ?? ResolveElementName(resolveExpression); case XamlContextDescription.InAttributeValue: MemberResolveResult mrr = ResolveAttribute(context.Attribute.Name); if (mrr != null) { var rr = ResolveAttributeValue(mrr.ResolvedMember, resolveExpression) ?? mrr; return rr; } break; case XamlContextDescription.InMarkupExtension: return ResolveMarkupExtension(resolveExpression); } return null; }
public void SetUpFixture() { RubyMSBuildEngineHelper.InitMSBuildEngine(); List<ProjectBindingDescriptor> bindings = new List<ProjectBindingDescriptor>(); using (TextReader reader = RubyBindingAddInFile.ReadAddInFile()) { AddIn addin = AddIn.Load(reader, String.Empty); bindings.Add(new ProjectBindingDescriptor(AddInHelper.GetCodon(addin, "/SharpDevelop/Workbench/ProjectBindings", "Ruby"))); } ProjectBindingService.SetBindings(bindings); convertProjectCommand = new DerivedConvertProjectToRubyProjectCommand(); parseInfo = new ParseInformation(new DefaultCompilationUnit(new DefaultProjectContent())); convertProjectCommand.ParseInfo = parseInfo; convertProjectCommand.FileServiceDefaultEncoding = Encoding.Unicode; sourceProject = new MockProject(); sourceProject.Directory = @"d:\projects\test"; source = new FileProjectItem(sourceProject, ItemType.Compile, @"src\Program.cs"); targetProject = (RubyProject)convertProjectCommand.CallCreateProject(@"d:\projects\test\converted", sourceProject); target = new FileProjectItem(targetProject, source.ItemType, source.Include); source.CopyMetadataTo(target); textFileSource = new FileProjectItem(sourceProject, ItemType.None, @"src\readme.txt"); textFileTarget = new FileProjectItem(targetProject, textFileSource.ItemType, textFileSource.Include); textFileSource.CopyMetadataTo(textFileTarget); convertProjectCommand.AddParseableFileContent(source.FileName, sourceCode); convertProjectCommand.CallConvertFile(source, target); convertProjectCommand.CallConvertFile(textFileSource, textFileTarget); }
public void Init() { projectContent = new MockProjectContent(); ParseInformation parseInfo = new ParseInformation(new DefaultCompilationUnit(projectContent)); PythonImportCompletion completion = new PythonImportCompletion(projectContent); completionItems = completion.GetCompletionItems(String.Empty); }
public void Init() { string python = "from sys import exit as myexit"; parseInfo = PythonParserHelper.CreateParseInfo(python); resolverContext = new PythonResolverContext(parseInfo); }
public PythonResolverContext(ParseInformation parseInfo, ExpressionResult expressionResult, string fileContent) { this.fileContent = fileContent; this.expressionResult = expressionResult; GetCompilationUnit(parseInfo); GetProjectContent(); GetCallingMember(); }
public void Init() { string python = "import math as m\r\n" + "import sys as s"; parseInfo = PythonParserHelper.CreateParseInfo(python); resolverContext = new PythonResolverContext(parseInfo); }
public VBNetToCSharpConvertVisitorWithMyFormsSupport(IProjectContent pc, ParseInformation parseInfo, string rootNamespace) : base(pc, parseInfo) { this.NamespacePrefixToAdd = rootNamespace; if (string.IsNullOrEmpty(rootNamespace)) vbMyFormsClass = CSharpMyNamespaceBuilder.FindMyFormsClass(pc, "My"); else vbMyFormsClass = CSharpMyNamespaceBuilder.FindMyFormsClass(pc, rootNamespace + ".My"); }
public PythonResolverTestsHelper(string code) { ProjectContent = new ScriptingUtils.MockProjectContent(); PythonParser parser = new PythonParser(); string fileName = @"test.py"; CompilationUnit = parser.Parse(ProjectContent, fileName, code) as DefaultCompilationUnit; ParseInfo = new ParseInformation(CompilationUnit); Resolver = new PythonResolver(); }
protected Dom.IMember GetParentMember(ITextEditor textEditor, int line, int column) { Dom.ParseInformation parseInfo = ParserService.GetParseInformation(textEditor.FileName); if (parseInfo != null) { return(parseInfo.CompilationUnit.GetInnermostMember(line, column)); } return(null); }
public void Init() { DefaultProjectContent projectContent = new DefaultProjectContent(); DefaultCompilationUnit unit = new DefaultCompilationUnit(projectContent); existingParseInfo = new ParseInformation(unit); parserService = new MockParserService(); parserService.SetExistingParseInformation(@"d:\projects\test.xml", existingParseInfo); }
public ParseInformationEventArgs(FileName fileName, IProjectContent projectContent, ICompilationUnit oldCompilationUnit, ParseInformation newParseInformation) { if (fileName == null) throw new ArgumentNullException("fileName"); if (projectContent == null) throw new ArgumentNullException("projectContent"); this.fileName = fileName; this.projectContent = projectContent; this.oldCompilationUnit = oldCompilationUnit; this.newParseInformation = newParseInformation; }
public void Init() { projectContent = new MockProjectContent(); ParseInformation parseInfo = new ParseInformation(new DefaultCompilationUnit(projectContent)); List<ICompletionEntry> namespaceItems = new List<ICompletionEntry>(); namespaceItems.Add(new NamespaceEntry("Test")); projectContent.AddExistingNamespaceContents(String.Empty, namespaceItems); PythonImportCompletion completion = new PythonImportCompletion(projectContent); completionItems = completion.GetCompletionItems(); }
public void SetUp() { displayBinding = new DerivedPythonFormsDesignerDisplayBinding(); viewContent = new MockTextEditorViewContent(); parseInfo = new ParseInformation(new DefaultCompilationUnit(new DefaultProjectContent())); viewContent.PrimaryFileName = new FileName("test.py"); viewContent.TextEditor.Document.Text = "text content"; displayBinding.ParseServiceParseInfoToReturn = parseInfo; displayBinding.IsParseInfoDesignable = true; canAttachToDesignableClass = displayBinding.CanAttachTo(viewContent); }
public MainForm() { // // The InitializeComponent() call is required for Windows Forms designer support. // InitializeComponent(); if (IsVisualBasic) { textEditorControl1.Text = @" Class A Sub B Dim xx As String End Sub End Class "; textEditorControl1.SetHighlighting("VBNET"); } else { textEditorControl1.Text = @"using System; class A { void B() { string x; } } "; textEditorControl1.SetHighlighting("C#"); } textEditorControl1.ShowEOLMarkers = false; textEditorControl1.ShowInvalidLines = false; HostCallbackImplementation.Register(this); CodeCompletionKeyHandler.Attach(this, textEditorControl1); ToolTipProvider.Attach(this, textEditorControl1); pcRegistry = new Dom.ProjectContentRegistry(); // Default .NET 2.0 registry // Persistence lets SharpDevelop.Dom create a cache file on disk so that // future starts are faster. // It also caches XML documentation files in an on-disk hash table, thus // reducing memory usage. pcRegistry.ActivatePersistence(Path.Combine(Path.GetTempPath(), "CSharpCodeCompletion")); myProjectContent = new Dom.DefaultProjectContent(); myProjectContent.Language = CurrentLanguageProperties; // create dummy parseInformation to prevent NullReferenceException when using CC before parsing // for the first time parseInformation = new Dom.ParseInformation(new Dom.DefaultCompilationUnit(myProjectContent)); }
public void Init() { projectContent = new MockProjectContent(); completion = new PythonImportCompletion(projectContent); DefaultCompilationUnit unit = new DefaultCompilationUnit(projectContent); ParseInformation parseInfo = new ParseInformation(unit); c = new DefaultClass(unit, "Class"); List<ICompletionEntry> namespaceItems = new List<ICompletionEntry>(); namespaceItems.Add(c); projectContent.AddExistingNamespaceContents("System", namespaceItems); }
public void SetUpFixture() { resolver = new PythonResolver(); mockProjectContent = new MockProjectContent(); List<ICompletionEntry> namespaceItems = new List<ICompletionEntry>(); namespaceItems.Add(new NamespaceEntry("Test")); mockProjectContent.AddExistingNamespaceContents(String.Empty, namespaceItems); ParseInformation parseInfo = new ParseInformation(new DefaultCompilationUnit(mockProjectContent)); results = resolver.CtrlSpace(0, "import".Length, parseInfo, "import", ExpressionContext.Namespace); }
void CreateParseInfoWithOneClassWithOneProperty() { projectContent = new ScriptingUtils.MockProjectContent(); myClass = new MockClass(projectContent, "MyClass"); myClassProperty = AddPropertyToClass("MyProperty", myClass); DefaultCompilationUnit unit = new DefaultCompilationUnit(projectContent); parseInfo = new ParseInformation(unit); projectContent.SetClassToReturnFromGetClass("MyClass", myClass); }
public void Init() { MockProjectContent projectContent = new MockProjectContent(); MockProjectContent winFormsReferenceProjectContent = new MockProjectContent(); List<ICompletionEntry> namespaceItems = new List<ICompletionEntry>(); winFormsReferenceProjectContent.AddExistingNamespaceContents("System.Windows.Forms", namespaceItems); projectContent.ReferencedContents.Add(winFormsReferenceProjectContent); DefaultCompilationUnit unit = new DefaultCompilationUnit(projectContent); parseInfo = new ParseInformation(unit); resolverContext = new PythonResolverContext(parseInfo); }
public void UpdateClassMemberBookmarks(ParseInformation parseInfo, TextDocument document) { for (int i = bookmarks.Count - 1; i >= 0; i--) { if (IsClassMemberBookmark(bookmarks[i])) bookmarks.RemoveAt(i); } if (parseInfo == null) return; foreach (IClass c in parseInfo.CompilationUnit.Classes) { AddClassMemberBookmarks(c, document); } }
public void SetUpFixture() { PythonParser parser = new PythonParser(); MockProjectContent mockProjectContent = new MockProjectContent(); ICompilationUnit compilationUnit = parser.Parse(mockProjectContent, @"C:\Projects\Test\MainForm.py", GetPythonCode()); parseInfo = new ParseInformation(compilationUnit); if (compilationUnit.Classes.Count > 0) { mainFormClass = compilationUnit.Classes[0]; initializeComponentsMethod = FormsDesignerSecondaryDisplayBinding.GetInitializeComponents(mainFormClass); } }
Variable ResolveVariable(Variable variable) { Dom.ParseInformation info = ParserService.GetParseInformation(this.textEditor.FileName); Dom.ExpressionResult res = new Dom.ExpressionResult(variable.Name, Dom.DomRegion.FromLocation(variable.StartPos, variable.EndPos), Dom.ExpressionContext.Default, null); Dom.ResolveResult result = this.GetResolver().Resolve(res, info, this.textEditor.Document.TextContent); if (variable.Type.Type == "var") { variable.Type = Dom.Refactoring.CodeGenerator.ConvertType(result.ResolvedType, new Dom.ClassFinder(result.CallingMember)); } variable.IsReferenceType = result.ResolvedType.IsReferenceType == true; return(variable); }
public ClassFinder(ParseInformation parseInfo, string fileContent, int offset) { caretLine = 0; caretColumn = 0; for (int i = 0; i < offset; i++) { if (fileContent[i] == '\n') { caretLine++; caretColumn = 0; } else { caretColumn++; } } Init(parseInfo); }
void Init(ParseInformation parseInfo) { if (parseInfo != null) { cu = parseInfo.MostRecentCompilationUnit; } if (cu != null) { callingClass = cu.GetInnermostClass(caretLine, caretColumn); projectContent = cu.ProjectContent; } else { projectContent = DefaultProjectContent.DummyProjectContent; } if (projectContent == null) { throw new ArgumentException("projectContent not found!"); } }
void Init(string fileName) { ParseInformation parseInfo = HostCallback.GetParseInformation(fileName); if (parseInfo != null) { cu = parseInfo.MostRecentCompilationUnit; } if (cu != null) { callingClass = cu.GetInnermostClass(caretLine, caretColumn); projectContent = cu.ProjectContent; } else { projectContent = HostCallback.GetCurrentProjectContent(); } if (projectContent == null) { throw new ArgumentException("projectContent not found!"); } }