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!");
}
}
