public override object VisitAnonymousMethodExpression(AnonymousMethodExpression anonymousMethodExpression, object data)
{
AnonymousMethodReturnType amrt = new AnonymousMethodReturnType(resolver.CompilationUnit);
foreach (ParameterDeclarationExpression param in anonymousMethodExpression.Parameters)
{
amrt.MethodParameters.Add(NRefactoryASTConvertVisitor.CreateParameter(param, resolver.CallingMember as IMethod, resolver.CallingClass, resolver.CompilationUnit));
}
return(amrt);
}
public ICompilationUnit setCurrentCompilationUnit(CompilationUnit compilationUnit)
{
if (compilationUnit == null)
return null;
NRefactoryASTConvertVisitor converter;
converter = new NRefactoryASTConvertVisitor(myProjectContent);
compilationUnit.AcceptVisitor(converter, null);
var newCompilationUnit = converter.Cu;
parseInformation.SetCompilationUnit(newCompilationUnit);
return newCompilationUnit;
}
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;
}
ICompilationUnit ParseCSharp(ICompilationUnit oldUnit, string fileContent)
{
ICSharpCode.NRefactory.IParser p = ICSharpCode.NRefactory.ParserFactory.CreateParser(ICSharpCode.NRefactory.SupportedLanguage.CSharp, new StringReader(fileContent));
p.ParseMethodBodies = false;
p.Parse();
NRefactoryASTConvertVisitor visitor = new NRefactoryASTConvertVisitor(pc);
visitor.VisitCompilationUnit(p.CompilationUnit, null);
Assert.AreEqual(0, p.Errors.Count, String.Format("Parse error preparing compilation unit: {0}", p.Errors.ErrorOutput));
visitor.Cu.ErrorsDuringCompile = p.Errors.Count > 0;
pc.UpdateCompilationUnit(oldUnit, visitor.Cu, null);
return visitor.Cu;
}
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", ""));
}
internal LambdaReturnType(AnonymousMethodExpression expression, NRefactoryResolver resolver)
: base(resolver.CompilationUnit)
{
this.resolver = resolver;
if (expression.HasParameterList)
{
base.MethodParameters = new List <IParameter>();
foreach (ParameterDeclarationExpression param in expression.Parameters)
{
base.MethodParameters.Add(NRefactoryASTConvertVisitor.CreateParameter(param, resolver.CallingMember as IMethod, resolver.CallingClass, resolver.CompilationUnit));
}
}
expression.Body.AcceptVisitor(new ReturnStatementFinder(returnExpressions), null);
}
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;
}
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(ICSharpCode.NRefactory.IParser p, string fileName, IProjectContent projectContent)
{
p.Lexer.SpecialCommentTags = lexerTags;
p.ParseMethodBodies = false;
p.Parse();
NRefactoryASTConvertVisitor visitor = new NRefactoryASTConvertVisitor(projectContent, ICSharpCode.NRefactory.SupportedLanguage.VBNet);
if (projectContent.Project != null) {
visitor.VBRootNamespace = ((IProject)projectContent.Project).RootNamespace;
}
visitor.Specials = p.Lexer.SpecialTracker.CurrentSpecials;
visitor.VisitCompilationUnit(p.CompilationUnit, null);
visitor.Cu.FileName = fileName;
visitor.Cu.ErrorsDuringCompile = p.Errors.Count > 0;
RetrieveRegions(visitor.Cu, p.Lexer.SpecialTracker);
AddCommentTags(visitor.Cu, p.Lexer.TagComments);
return visitor.Cu;
}
internal LambdaReturnType(LambdaExpression expression, NRefactoryResolver resolver)
: base(resolver.CompilationUnit)
{
this.resolver = resolver;
this.lambdaExpression = expression;
base.MethodParameters = new List <IParameter>();
foreach (ParameterDeclarationExpression param in expression.Parameters)
{
base.MethodParameters.Add(NRefactoryASTConvertVisitor.CreateParameter(param, resolver.CallingMember as IMethod, resolver.CallingClass, resolver.CompilationUnit));
}
if (expression.ExpressionBody.IsNull)
{
expression.StatementBody.AcceptVisitor(new ReturnStatementFinder(returnExpressions), null);
}
else
{
returnExpressions.Add(expression.ExpressionBody);
}
}
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);
}
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, sourceLanguage);
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(visitor.Cu);
return result;
}
public ICompilationUnit ConvertCompilationUnit(CompilationUnit compilationUnit)
{
var converter = new NRefactoryASTConvertVisitor(myProjectContent);
compilationUnit.AcceptVisitor(converter, null);
return converter.Cu;
}
private ICompilationUnit ConvertCompilationUnit(CompilationUnit cu)
{
var supportedLanguage = SupportedLanguage == SupportedLanguage.CSharp
? ICSharpCode.NRefactory.SupportedLanguage.CSharp
: ICSharpCode.NRefactory.SupportedLanguage.VBNet;
var converter = new NRefactoryASTConvertVisitor(ProjectContent, supportedLanguage);
cu.AcceptVisitor(converter, null);
return converter.Cu;
}
private ICompilationUnit ConvertCompilationUnit(CompilationUnit cu)
{
NRefactoryASTConvertVisitor converter;
converter = new NRefactoryASTConvertVisitor(myProjectContent);
cu.AcceptVisitor(converter, null);
return converter.Cu;
}
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);
}