public void CanGetProjectContentPassedToGetExistingParseInfoMethod()
{
DefaultProjectContent projectContent = new DefaultProjectContent();
parserService.GetExistingParseInformation(projectContent, "file.xml");
Assert.AreSame(projectContent, parserService.ProjectContentPassedToGetExistingParseInforMethod);
}
public void ParseWithNullFileContent()
{
DefaultProjectContent projectContent = new DefaultProjectContent();
ICompilationUnit unit = parser.Parse(projectContent, null, (ICSharpCode.SharpDevelop.ITextBuffer)null);
Assert.IsInstanceOf(typeof(DefaultCompilationUnit), unit);
}
public void SetUpFixture()
{
string python = "class Test:\r\n" +
"\tdef __init__(self):\r\n" +
"\t\tpass\r\n";
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];
}
// Get folds.
ParserFoldingStrategy foldingStrategy = new ParserFoldingStrategy();
ParseInformation parseInfo = new ParseInformation();
parseInfo.SetCompilationUnit(compilationUnit);
DocumentFactory docFactory = new DocumentFactory();
IDocument doc = docFactory.CreateDocument();
doc.TextContent = python;
List <FoldMarker> markers = foldingStrategy.GenerateFoldMarkers(doc, @"C:\Temp\test.py", parseInfo);
if (markers.Count > 1)
{
classMarker = markers[0];
methodMarker = markers[1];
}
}
}
// usingMode: 0 = one using-statement for each namespace (correctly cased)
// 1 = mixture of using statements and default imports (incorrectly cased)
// 2 = all default imports (incorrectly cased)
ICompilationUnit Prepare(LanguageProperties language, int usingMode)
{
DefaultProjectContent pc = new DefaultProjectContent();
pc.ReferencedContents.Add(projectContentRegistry.Mscorlib);
pc.Language = language;
DefaultCompilationUnit cu = new DefaultCompilationUnit(pc);
if (usingMode == 1)
{
cu.Usings.Add(CreateUsing(pc, "syStEm.coLLectIons"));
pc.DefaultImports = new DefaultUsing(pc);
pc.DefaultImports.Usings.Add("syStEm");
pc.DefaultImports.Usings.Add("syStEm.coLLEctionS.GeNeRic");
}
else if (usingMode == 2)
{
pc.DefaultImports = new DefaultUsing(pc);
pc.DefaultImports.Usings.Add("syStEm");
pc.DefaultImports.Usings.Add("syStEm.coLLEctioNs");
pc.DefaultImports.Usings.Add("syStEm.coLLEctionS.GeNeRic");
}
else // usingMode == 0
{
cu.Usings.Add(CreateUsing(pc, "System"));
cu.Usings.Add(CreateUsing(pc, "System.Collections"));
cu.Usings.Add(CreateUsing(pc, "System.Collections.Generic"));
}
return(cu);
}
public CSProject(string name, Uri location)
: base(name, location)
{
FProjectContent = new DefaultProjectContent();
FProjectContent.Language = LanguageProperties.CSharp;
Loaded += MsBuildProject_Loaded;
}
public static void add_Reference(this DefaultProjectContent projectContent, ProjectContentRegistry pcRegistry, string assemblyToLoad, Action <string> debugMessage)
{
try
{
debugMessage("Loading Code Completion Reference: {0}".format(assemblyToLoad));
//if (!assemblyToLoad.fileExists())
// "file doesn't exist".error();
IProjectContent referenceProjectContent = pcRegistry.GetProjectContentForReference(assemblyToLoad, assemblyToLoad);
if (referenceProjectContent == null)
{
"referenceProjectContent was null".error();
}
else
{
projectContent.AddReferencedContent(referenceProjectContent);
if (referenceProjectContent is ReflectionProjectContent)
{
(referenceProjectContent as ReflectionProjectContent).InitializeReferences();
}
else
{
"something when wrong in DefaultProjectContent.add_Reference".error();
}
}
}
catch (Exception ex)
{
ex.log("in DefaultProjectContent.add_Reference");
}
}
public void setupEnvironment()
{
try
{
textEditor.ActiveTextAreaControl.TextArea.KeyEventHandler += TextAreaKeyEventHandler;
textEditor.ActiveTextAreaControl.TextArea.Caret.PositionChanged += Caret_PositionChanged;
textEditor.Disposed += CloseCodeCompletionWindow; // When the editor is disposed, close the code completion window
//set up the ToolTipRequest event
textEditor.ActiveTextAreaControl.TextArea.ToolTipRequest += OnToolTipRequest;
this.pcRegistry = new ProjectContentRegistry();
this.myProjectContent = new DefaultProjectContent();
this.myProjectContent.Language = this.CurrentLanguageProperties;
var persistanceFolder = Path.Combine(Path.GetTempPath(), "CSharpCodeCompletion");
persistanceFolder.createFolder();
pcRegistry.ActivatePersistence(persistanceFolder);
// static parse current code thread
//startParseCodeThread();
// add references
startAddReferencesThread();
startParseCodeThread();
}
catch (Exception ex)
{
ex.log("in setupEnvironment");
}
}
ICompilationUnit Parse(string code)
{
var projectContent = new DefaultProjectContent();
var textBuffer = new StringTextBuffer(code);
return(parser.Parse(projectContent, @"d:\MyProject\Views\Index.cshtml", textBuffer));
}
ICompilationUnit ParseVB(string fileName, string fileContent)
{
ICSharpCode.NRefactory.IParser p = ICSharpCode.NRefactory.ParserFactory.CreateParser(ICSharpCode.NRefactory.SupportedLanguage.VBNet, new StringReader(fileContent));
p.ParseMethodBodies = false;
p.Parse();
DefaultProjectContent pc = new DefaultProjectContent();
HostCallback.GetCurrentProjectContent = delegate {
return(pc);
};
pc.ReferencedContents.Add(projectContentRegistry.Mscorlib);
pc.ReferencedContents.Add(projectContentRegistry.GetProjectContentForReference("System.Windows.Forms", "System.Windows.Forms"));
pc.Language = LanguageProperties.VBNet;
lastPC = pc;
NRefactoryASTConvertVisitor visitor = new NRefactoryASTConvertVisitor(pc);
visitor.VisitCompilationUnit(p.CompilationUnit, null);
visitor.Cu.FileName = fileName;
Assert.AreEqual(0, p.Errors.Count, "Parse error preparing compilation unit");
visitor.Cu.ErrorsDuringCompile = p.Errors.Count > 0;
foreach (IClass c in visitor.Cu.Classes)
{
pc.AddClassToNamespaceList(c);
}
return(visitor.Cu);
}
static void CreateDefaultProjectContent()
{
LoggingService.Info("Creating default project content");
//LoggingService.Debug("Stacktrace is:\n" + Environment.StackTrace);
defaultProjectContent = new DefaultProjectContent();
defaultProjectContent.AddReferencedContent(AssemblyParserService.DefaultProjectContentRegistry.Mscorlib);
}
public object GetDescription(DesignItemProperty property)
{
IProjectContent pc = MyTypeFinder.GetProjectContent(file);
if (pc != null)
{
// For attached Properties
if (property.DependencyFullName != null && property.Name.Contains("."))
{
IClass c = pc.GetClassByReflectionName(property.DependencyProperty.OwnerType.FullName, true);
if (c != null)
{
IMember m = DefaultProjectContent.GetMemberByReflectionName(c, property.DependencyProperty.Name + "Property");
if (m != null)
{
return(CodeCompletionItem.ConvertDocumentation(m.Documentation));
}
}
}
else
{
IClass c = pc.GetClassByReflectionName(property.DeclaringType.FullName, true);
if (c != null)
{
IMember m = DefaultProjectContent.GetMemberByReflectionName(c, property.Name);
if (m != null)
{
return(CodeCompletionItem.ConvertDocumentation(m.Documentation));
}
}
}
}
return(null);
}
/// <summary>
/// Initializes a new instance of the <see cref="MainForm"/> class.
/// </summary>
public MainForm()
{
// The InitializeComponent() call is required for Windows Forms designer support.
InitializeComponent();
textEditorControl1.ShowEOLMarkers = false;
textEditorControl1.ShowInvalidLines = false;
HostCallbackImplementation.Register(this);
CodeCompletionKeyHandler.Attach(this, textEditorControl1);
ToolTipProvider.Attach(this, textEditorControl1);
PcRegistry = new 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.
// Paul Meems, 1 Sept. 2010: Create the file if it doesn't exist (Bug #1763):
string cacheFolder = Path.Combine(Path.GetTempPath(), "CSharpCodeCompletion");
if (!Directory.Exists(cacheFolder))
{
Directory.CreateDirectory(cacheFolder);
}
PcRegistry.ActivatePersistence(cacheFolder);
MyProjectContent = new DefaultProjectContent
{
Language = IsVisualBasic ? LanguageProperties.VBNet : LanguageProperties.CSharp
};
}
public void ParseWithNullFileContent()
{
DefaultProjectContent projectContent = new DefaultProjectContent();
ICompilationUnit unit = parser.Parse(projectContent, null, null);
Assert.IsInstanceOf(typeof(DefaultCompilationUnit), unit);
}
public MockTextEditor()
: base(new TextEditor())
{
PropertyService.InitializeServiceForUnitTests();
pc = new DefaultProjectContent();
pc.Language = LanguageProperties.VBNet;
pc.ReferencedContents.Add(AssemblyParserService.DefaultProjectContentRegistry.Mscorlib);
Dictionary <string, string> referencedAssemblies = new Dictionary <string, string>()
{
{ "System", typeof(Uri).Module.FullyQualifiedName },
{ "System.Core", typeof(Enumerable).Module.FullyQualifiedName },
{ "Microsoft.VisualBasic", typeof(Microsoft.VisualBasic.Constants).Module.FullyQualifiedName }
};
foreach (var assembly in referencedAssemblies)
{
IProjectContent referenceProjectContent = AssemblyParserService.DefaultProjectContentRegistry.GetProjectContentForReference(assembly.Key, assembly.Value ?? assembly.Key);
if (referenceProjectContent == null)
{
throw new Exception("Error loading " + assembly.Key);
}
pc.ReferencedContents.Add(referenceProjectContent);
if (referenceProjectContent is ReflectionProjectContent)
{
(referenceProjectContent as ReflectionProjectContent).InitializeReferences();
}
}
// this.TextEditor.TextArea.TextView.Services.AddService(typeof(ISyntaxHighlighter), new AvalonEditSyntaxHighlighterAdapter(this.TextEditor));
this.TextEditor.SyntaxHighlighting = HighlightingManager.Instance.GetDefinition("VBNet");
new VBNetLanguageBinding().Attach(this);
}
INode Parse(SupportedLanguage sourceLanguage, string sourceCode, out string error)
{
project = new DefaultProjectContent();
project.ReferencedContents.AddRange(ReferencedContents);
if (sourceLanguage == SupportedLanguage.VBNet) {
project.Language = LanguageProperties.VBNet;
project.DefaultImports = new DefaultUsing(project);
project.DefaultImports.Usings.AddRange(DefaultImportsToAdd);
} else {
project.Language = LanguageProperties.CSharp;
}
SnippetParser parser = new SnippetParser(sourceLanguage);
INode result = parser.Parse(sourceCode);
error = parser.Errors.ErrorOutput;
specials = parser.Specials;
if (parser.Errors.Count != 0)
return null;
wasExpression = parser.SnippetType == SnippetType.Expression;
if (wasExpression) {
// Special case 'Expression': expressions may be replaced with other statements in the AST by the ConvertVisitor,
// but we need to return a 'stable' node so that the correct transformed AST is returned.
// Thus, we wrap any expressions into a statement block.
result = MakeBlockFromExpression((Expression)result);
}
// now create a dummy compilation unit around the snippet result
switch (parser.SnippetType) {
case SnippetType.CompilationUnit:
compilationUnit = (CompilationUnit)result;
break;
case SnippetType.Expression:
case SnippetType.Statements:
compilationUnit = MakeCompilationUnitFromTypeMembers(
MakeMethodFromBlock(
(BlockStatement)result
));
break;
case SnippetType.TypeMembers:
compilationUnit = MakeCompilationUnitFromTypeMembers(result.Children);
break;
default:
throw new NotSupportedException("Unknown snippet type: " + parser.SnippetType);
}
// convert NRefactory CU in DOM CU
NRefactoryASTConvertVisitor visitor = new NRefactoryASTConvertVisitor(project);
visitor.VisitCompilationUnit(compilationUnit, null);
visitor.Cu.FileName = sourceLanguage == SupportedLanguage.CSharp ? "a.cs" : "a.vb";
// and register the compilation unit in the DOM
foreach (IClass c in visitor.Cu.Classes) {
project.AddClassToNamespaceList(c);
}
parseInfo = new ParseInformation();
parseInfo.SetCompilationUnit(visitor.Cu);
return result;
}
public void ParseWithNullTextBuffer()
{
DefaultProjectContent projectContent = new DefaultProjectContent();
ITextBuffer textBuffer = null;
ICompilationUnit unit = parser.Parse(projectContent, null, textBuffer);
Assert.IsInstanceOf(typeof(DefaultCompilationUnit), unit);
}
public static ParseInformation CreateParseInfo(string code)
{
DefaultProjectContent projectContent = new DefaultProjectContent();
PythonParser parser = new PythonParser();
ICompilationUnit compilationUnit = parser.Parse(projectContent, @"C:\test.py", code);
return(new ParseInformation(compilationUnit));
}
public CSProject(string path)
: base(path)
{
FProjectContent = new DefaultProjectContent();
FProjectContent.Language = LanguageProperties.CSharp;
References.Added += References_Changed;
References.Removed += References_Changed;
}
void TestProgram(SupportedLanguage sourceLanguage, string sourceCode, string expectedOutput)
{
DefaultProjectContent pc = new DefaultProjectContent();
pc.ReferencedContents.Add(projectContentRegistry.Mscorlib);
pc.ReferencedContents.Add(projectContentRegistry.GetProjectContentForReference("System.Windows.Forms", "System.Windows.Forms"));
if (sourceLanguage == SupportedLanguage.VBNet)
{
pc.ReferencedContents.Add(projectContentRegistry.GetProjectContentForReference("Microsoft.VisualBasic", "Microsoft.VisualBasic"));
pc.DefaultImports = new DefaultUsing(pc);
pc.DefaultImports.Usings.Add("System");
pc.DefaultImports.Usings.Add("Microsoft.VisualBasic");
}
pc.Language = sourceLanguage == SupportedLanguage.CSharp ? LanguageProperties.CSharp : LanguageProperties.VBNet;
HostCallback.GetCurrentProjectContent = delegate {
return(pc);
};
ICSharpCode.NRefactory.IParser parser = ParserFactory.CreateParser(sourceLanguage, new StringReader(sourceCode));
parser.Parse();
Assert.AreEqual("", parser.Errors.ErrorOutput);
NRefactoryASTConvertVisitor visitor = new NRefactoryASTConvertVisitor(pc);
visitor.VisitCompilationUnit(parser.CompilationUnit, null);
visitor.Cu.FileName = sourceLanguage == SupportedLanguage.CSharp ? "a.cs" : "a.vb";
foreach (IClass c in visitor.Cu.Classes)
{
pc.AddClassToNamespaceList(c);
}
ParseInformation parseInfo = new ParseInformation();
parseInfo.SetCompilationUnit(visitor.Cu);
if (sourceLanguage == SupportedLanguage.CSharp)
{
CSharpToVBNetConvertVisitor convertVisitor = new CSharpToVBNetConvertVisitor(pc, parseInfo);
convertVisitor.RootNamespaceToRemove = "RootNamespace";
parser.CompilationUnit.AcceptVisitor(convertVisitor, null);
}
else
{
VBNetToCSharpConvertVisitor convertVisitor = new VBNetToCSharpConvertVisitor(pc, parseInfo);
parser.CompilationUnit.AcceptVisitor(convertVisitor, null);
}
IOutputAstVisitor outputVisitor = sourceLanguage == SupportedLanguage.CSharp ? (IOutputAstVisitor) new VBNetOutputVisitor() : new CSharpOutputVisitor();
outputVisitor.Options.IndentationChar = ' ';
outputVisitor.Options.IndentSize = 2;
using (SpecialNodesInserter.Install(parser.Lexer.SpecialTracker.RetrieveSpecials(),
outputVisitor)) {
outputVisitor.VisitCompilationUnit(parser.CompilationUnit, null);
}
Assert.AreEqual("", outputVisitor.Errors.ErrorOutput);
Assert.AreEqual(expectedOutput.Replace("\r", ""), outputVisitor.Text.Trim().Replace("\r", ""));
}
public void SetUpFixture()
{
string python = "class";
DefaultProjectContent projectContent = new DefaultProjectContent();
PythonParser parser = new PythonParser();
compilationUnit = parser.Parse(projectContent, @"C:\test.py", python);
}
public void SetUpFixture()
{
string Ruby = "require \"System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089\"";
DefaultProjectContent projectContent = new DefaultProjectContent();
RubyParser parser = new RubyParser();
compilationUnit = parser.Parse(projectContent, @"C:\test.rb", Ruby);
}
public PythonModuleCompletionItems(PythonStandardModuleType moduleType)
{
projectContent = new DefaultProjectContent();
compilationUnit = new DefaultCompilationUnit(projectContent);
moduleClass = new DefaultClass(compilationUnit, moduleType.Name);
AddCompletionItemsForType(moduleType.Type);
AddStandardCompletionItems();
}
void TestMember(string className, string memberName)
{
IClass c = mscorlib.GetClassByReflectionName(className, false);
Assert.IsNotNull(c);
AbstractMember m = (AbstractMember)DefaultProjectContent.GetMemberByReflectionName(c, memberName);
Assert.AreEqual(className + "." + memberName, m.DocumentationTag.Substring(2));
}
public void Parse_ProjectContentPassed_ReturnsCompilationUnitWithProjectContent()
{
var expectedProjectContent = new DefaultProjectContent();
ParseEmptyJavaScriptFileWithProjectContent(expectedProjectContent);
IProjectContent projectContent = compilationUnit.ProjectContent;
Assert.AreEqual(expectedProjectContent, projectContent);
}
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 MockTextEditor()
: base(new TextEditor())
{
PropertyService.InitializeServiceForUnitTests();
pc = new DefaultProjectContent();
pc.ReferencedContents.Add(AssemblyParserService.DefaultProjectContentRegistry.Mscorlib);
// this.TextEditor.TextArea.TextView.Services.AddService(typeof(ISyntaxHighlighter), new AvalonEditSyntaxHighlighterAdapter(this.TextEditor));
this.TextEditor.SyntaxHighlighting = HighlightingManager.Instance.GetDefinition("C#");
}
public void Init()
{
string python = "from math import *";
DefaultProjectContent projectContent = new DefaultProjectContent();
PythonParser parser = new PythonParser();
compilationUnit = parser.Parse(projectContent, @"C:\test.py", python);
import = compilationUnit.UsingScope.Usings[0] as PythonFromImport;
}
/// <summary>
/// Initializes a new instance of the <see cref="MainForm"/> class.
/// </summary>
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 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.
// Paul Meems, 1 Sept. 2010: Create the file if it doesn't exist (Bug #1763):
string cacheFolder = Path.Combine(Path.GetTempPath(), "CSharpCodeCompletion");
if (!Directory.Exists(cacheFolder))
{
Directory.CreateDirectory(cacheFolder);
}
pcRegistry.ActivatePersistence(cacheFolder);
myProjectContent = new DefaultProjectContent();
myProjectContent.Language = CurrentLanguageProperties;
}
INode Parse(SupportedLanguage sourceLanguage, string sourceCode, out string error)
{
project = new DefaultProjectContent();
project.ReferencedContents.AddRange(ReferencedContents);
if (sourceLanguage == SupportedLanguage.VBNet) {
project.DefaultImports = new DefaultUsing(project);
project.DefaultImports.Usings.AddRange(DefaultImportsToAdd);
}
SnippetParser parser = new SnippetParser(sourceLanguage);
INode result = parser.Parse(sourceCode);
error = parser.Errors.ErrorOutput;
specials = parser.Specials;
if (parser.Errors.Count != 0)
return null;
// now create a dummy compilation unit around the snippet result
switch (parser.SnippetType) {
case SnippetType.CompilationUnit:
compilationUnit = (CompilationUnit)result;
break;
case SnippetType.Expression:
compilationUnit = MakeCompilationUnitFromTypeMembers(
MakeMethodFromBlock(
MakeBlockFromExpression(
(Expression)result
)));
break;
case SnippetType.Statements:
compilationUnit = MakeCompilationUnitFromTypeMembers(
MakeMethodFromBlock(
(BlockStatement)result
));
break;
case SnippetType.TypeMembers:
compilationUnit = MakeCompilationUnitFromTypeMembers(result.Children);
break;
default:
throw new NotSupportedException("Unknown snippet type: " + parser.SnippetType);
}
// convert NRefactory CU in DOM CU
NRefactoryASTConvertVisitor visitor = new NRefactoryASTConvertVisitor(project);
visitor.VisitCompilationUnit(compilationUnit, null);
visitor.Cu.FileName = sourceLanguage == SupportedLanguage.CSharp ? "a.cs" : "a.vb";
// and register the compilation unit in the DOM
foreach (IClass c in visitor.Cu.Classes) {
project.AddClassToNamespaceList(c);
}
parseInfo = new ParseInformation();
parseInfo.SetCompilationUnit(visitor.Cu);
return result;
}
public void SetUpFixture()
{
string ruby = "class Class1\r\n" +
" @\r\n" +
"end";
DefaultProjectContent projectContent = new DefaultProjectContent();
RubyParser parser = new RubyParser();
compilationUnit = parser.Parse(projectContent, @"C:\test.rb", ruby);
}
public void ParseDoesNotThrowNullReferenceException()
{
string ruby = "require #";
DefaultProjectContent projectContent = new DefaultProjectContent();
RubyParser parser = new RubyParser();
ICompilationUnit unit = null;
Assert.DoesNotThrow(delegate { unit = parser.Parse(projectContent, @"C:\test.rb", ruby); });
Assert.IsNotNull(unit);
}
static void CreateDefaultProjectContent()
{
LoggingService.Info("Creating default project content");
//LoggingService.Debug("Stacktrace is:\n" + Environment.StackTrace);
defaultProjectContent = new DefaultProjectContent();
defaultProjectContent.AddReferencedContent(defaultProjectContentRegistry.Mscorlib);
Thread t = new Thread(new ThreadStart(CreateDefaultProjectContentReferences));
t.IsBackground = true;
t.Priority = ThreadPriority.BelowNormal;
t.Name = "CreateDefaultPC";
t.Start();
}
ICompilationUnit Parse(string code, SupportedLanguage language, bool referenceMscorlib)
{
DefaultProjectContent pc = new DefaultProjectContent();
if (referenceMscorlib) {
pc.AddReferencedContent(SharedProjectContentRegistryForTests.Instance.Mscorlib);
}
NRefactoryASTConvertVisitor visitor = new NRefactoryASTConvertVisitor(pc);
using (IParser p = ParserFactory.CreateParser(language, new StringReader(code))) {
p.ParseMethodBodies = false;
p.Parse();
visitor.Specials = p.Lexer.SpecialTracker.CurrentSpecials;
visitor.VisitCompilationUnit(p.CompilationUnit, null);
}
return visitor.Cu;
}
ICompilationUnit Parse(string code, SupportedLanguage language, params IProjectContent[] references)
{
DefaultProjectContent pc = new DefaultProjectContent();
foreach (var reference in references) {
pc.AddReferencedContent(reference);
}
NRefactoryASTConvertVisitor visitor = new NRefactoryASTConvertVisitor(pc, language);
using (IParser p = ParserFactory.CreateParser(language, new StringReader(code))) {
p.ParseMethodBodies = false;
p.Parse();
visitor.Specials = p.Lexer.SpecialTracker.CurrentSpecials;
visitor.VisitCompilationUnit(p.CompilationUnit, null);
}
return visitor.Cu;
}
public void NestedInterfaceInGenericClass()
{
// See SD2-1626
DefaultProjectContent pc = new DefaultProjectContent();
pc.ReferencedContents.Add(SharedProjectContentRegistryForTests.Instance.Mscorlib);
DefaultCompilationUnit cu = new DefaultCompilationUnit(pc);
DefaultClass container = new DefaultClass(cu, "TestClass");
container.TypeParameters.Add(new DefaultTypeParameter(container, "T", 0));
DefaultClass innerClass = new DefaultClass(cu, container);
innerClass.FullyQualifiedName = "TestClass.INestedInterface";
innerClass.ClassType = ClassType.Interface;
innerClass.TypeParameters.Add(new DefaultTypeParameter(innerClass, "T", 0));
innerClass.Properties.Add(new DefaultProperty(innerClass, "P") {
ReturnType = new GenericReturnType(innerClass.TypeParameters[0]),
CanGet = true
});
container.InnerClasses.Add(innerClass);
pc.AddClassToNamespaceList(container);
DefaultClass targetClass = new DefaultClass(cu, "TargetClass");
List<AbstractNode> nodes = new List<AbstractNode>();
IReturnType interf = new SearchClassReturnType(pc, targetClass, 0, 0, "TestClass.INestedInterface", 1);
interf = new ConstructedReturnType(interf, new IReturnType[] { SharedProjectContentRegistryForTests.Instance.Mscorlib.GetClass("System.String", 0).DefaultReturnType });
CSharpCodeGenerator codeGen = new CSharpCodeGenerator();
codeGen.ImplementInterface(nodes, interf, true, targetClass);
Assert.AreEqual(1, nodes.Count);
CSharpOutputVisitor output = new CSharpOutputVisitor();
output.Options.IndentationChar = ' ';
output.Options.IndentSize = 2;
nodes[0].AcceptVisitor(output, null);
Assert.AreEqual("string TestClass<string>.INestedInterface.P {\n get {\n throw new NotImplementedException();\n }\n}", output.Text.Replace("\r", "").Trim());
}
public void SetUp()
{
pc = new DefaultProjectContent();
}
void CreateDefaultClass(string fullyQualifiedName)
{
projectContent = new DefaultProjectContent();
compilationUnit = new DefaultCompilationUnit(projectContent);
defaultClass = new DefaultClass(compilationUnit, fullyQualifiedName);
}
