public override void AcceptVisitor(StatementVisitor visitor)
{
visitor.VisitParameterExpression(this);
}
public override R Accept <R>(StatementVisitor <R> vis)
{
return(vis.Visit(this));
}
void CheckUpdatedCompilation(Compilation originalCompilation, Compilation updatedCompilation){
this.WriteOutAnyErrors();
if (originalCompilation != updatedCompilation){
Console.WriteLine("update of {0} resulted in a new compilation instance", originalCompilation.TargetModule.Name);
return;
}
CompilationUnit updatedCompilationUnit = null;
for (int i = 0, n = updatedCompilation.CompilationUnits == null ? 0 : updatedCompilation.CompilationUnits.Count; i < n; i++){
if (updatedCompilation.CompilationUnits[i] == null)
Console.WriteLine("updated compilation unit {0} is null", i);
else if (updatedCompilation.CompilationUnits[i].Name.UniqueIdKey == this.compilationUnit.Name.UniqueIdKey){
updatedCompilationUnit = updatedCompilation.CompilationUnits[i];
break;
}
}
StatementVisitor statVis = new StatementVisitor();
statVis.Visit(updatedCompilationUnit);
}
public override MemberDeclarationSyntax VisitForClass(ConversionContext context, ClassDeclarationSyntax classSyntax, ConstructorDeclaration ctorDecl)
{
var ctorSyntax = SyntaxFactory.ConstructorDeclaration(classSyntax.Identifier.Value.ToString())
.WithLeadingTrivia(SyntaxFactory.CarriageReturnLineFeed);
var mods = ctorDecl.getModifiers();
if (mods.HasFlag(Modifier.PUBLIC))
{
ctorSyntax = ctorSyntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword));
}
if (mods.HasFlag(Modifier.PROTECTED))
{
ctorSyntax = ctorSyntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.ProtectedKeyword));
}
if (mods.HasFlag(Modifier.PRIVATE))
{
ctorSyntax = ctorSyntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.PrivateKeyword));
}
var parameters = ctorDecl.getParameters().ToList <Parameter>();
if (parameters != null && parameters.Count > 0)
{
var paramSyntaxes = new List <ParameterSyntax>();
foreach (var param in parameters)
{
var name = param.getId().toString();
var paramSyntax = SyntaxFactory.Parameter(SyntaxFactory.ParseToken(TypeHelper.ConvertIdentifierName(name)));
if (param.isVarArgs())
{
paramSyntax = paramSyntax.WithType(SyntaxFactory.ParseTypeName(TypeHelper.ConvertType(param.getType().toString()) + "[]"))
.WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ParamsKeyword)));
}
else
{
paramSyntax = paramSyntax.WithType(SyntaxFactory.ParseTypeName(TypeHelper.ConvertType(param.getType().toString())));
}
paramSyntaxes.Add(paramSyntax);
}
ctorSyntax = ctorSyntax.AddParameterListParameters(paramSyntaxes.ToArray());
}
//chaws: var block = ctorDecl.getBlock();
var block = ctorDecl.getBody();
var statements = block.getStmts().ToList <Statement>();
// handle special case for constructor invocation
if (statements != null && statements.Count > 0 && statements[0] is ExplicitConstructorInvocationStmt)
{
var ctorInvStmt = (ExplicitConstructorInvocationStmt)statements[0];
statements.RemoveAt(0);
ArgumentListSyntax argsSyntax = null;
var initargs = ctorInvStmt.getArgs().ToList <Expression>();
if (initargs != null && initargs.Count > 0)
{
var initargslist = new List <ArgumentSyntax>();
foreach (var arg in initargs)
{
var argsyn = ExpressionVisitor.VisitExpression(context, arg);
initargslist.Add(SyntaxFactory.Argument(argsyn));
}
argsSyntax = SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(initargslist, Enumerable.Repeat(SyntaxFactory.Token(SyntaxKind.CommaToken), initargslist.Count - 1)));
}
ConstructorInitializerSyntax ctorinitsyn;
if (ctorInvStmt.isThis())
{
ctorinitsyn = SyntaxFactory.ConstructorInitializer(SyntaxKind.ThisConstructorInitializer, argsSyntax);
}
else
{
ctorinitsyn = SyntaxFactory.ConstructorInitializer(SyntaxKind.BaseConstructorInitializer, argsSyntax);
}
ctorSyntax = ctorSyntax.WithInitializer(ctorinitsyn);
}
var statementSyntax = StatementVisitor.VisitStatements(context, statements);
ctorSyntax = ctorSyntax.AddBodyStatements(statementSyntax.ToArray());
return(ctorSyntax);
}
public override void VisitConstructorDeclaration(IConstructorDeclaration decl, SST context)
{
_cancellationToken.ThrowIfCancellationRequested();
var nameGen = new UniqueVariableNameGenerator();
var exprVisit = new ExpressionVisitor(nameGen, _marker);
if (decl.DeclaredElement != null)
{
var methodName = decl.DeclaredElement.GetName <IMethodName>();
var sstDecl = new MethodDeclaration
{
Name = methodName,
IsEntryPoint = _entryPoints.Contains(methodName)
};
context.Methods.Add(sstDecl);
if (decl == _marker.HandlingNode && _marker.Case == CompletionCase.InBody)
{
sstDecl.Body.Add(new ExpressionStatement {
Expression = new CompletionExpression()
});
}
if (decl.Initializer != null)
{
var name = Names.UnknownMethod;
var substitution = decl.DeclaredElement.IdSubstitution;
var resolvedRef = decl.Initializer.Reference.Resolve();
if (resolvedRef.DeclaredElement != null)
{
name = resolvedRef.DeclaredElement.GetName <IMethodName>(substitution);
}
var args = Lists.NewList <ISimpleExpression>();
foreach (var p in decl.Initializer.Arguments)
{
var expr = exprVisit.ToSimpleExpression(p.Value, sstDecl.Body);
args.Add(expr);
}
var varId = new VariableReference().Identifier; // default value
if (decl.Initializer.Instance != null)
{
var tokenType = decl.Initializer.Instance.GetTokenType();
var isThis = CSharpTokenType.THIS_KEYWORD == tokenType;
var isBase = CSharpTokenType.BASE_KEYWORD == tokenType;
varId = isThis ? "this" : isBase ? "base" : varId;
}
sstDecl.Body.Add(
new ExpressionStatement
{
Expression = new InvocationExpression
{
Reference = new VariableReference {
Identifier = varId
},
MethodName = name,
Parameters = args
}
});
}
if (!decl.IsAbstract)
{
var bodyVisitor = new StatementVisitor(nameGen, _marker);
Execute.AndSupressExceptions(
delegate { decl.Accept(bodyVisitor, sstDecl.Body); });
}
}
}
public abstract void AcceptVisitor(StatementVisitor visitor);
public override void visit(StatementVisitor visitor)
{
visitor.visit_import(this);
}
public override void AcceptVisitor(StatementVisitor visitor)
{
this.Delegate?.AcceptVisitor(visitor);
}
public override void visit(StatementVisitor visitor)
{
visitor.visit_expression(this);
}
public override void visit(StatementVisitor visitor)
{
visitor.visit_using(this);
}
public override void visit(StatementVisitor visitor)
{
visitor.visit_block(this);
}
public abstract void visit(StatementVisitor visitor);
public override void visit(StatementVisitor visitor)
{
visitor.visit_while(this);
}
public abstract void Visit(StatementVisitor visitor);
public override void visit(StatementVisitor visitor)
{
visitor.visit_return(this);
}
public override void visit(StatementVisitor visitor)
{
visitor.visit_interrupt(this);
}
public override void visit(StatementVisitor visitor)
{
visitor.visit_continue(this);
}
public abstract Statement visit(StatementVisitor v);
public void AcceptVisitor(StatementVisitor visitor)
{
visitor.VisitReferenceToMethodParameter(this);
}
public override T AcceptVisitor <T, C>(StatementVisitor <T, C> visitor, C context)
{
return(visitor.VisitVariableDeclarationStatement(this, context));
}
public override void AcceptVisitor(StatementVisitor visitor)
{
Condition.AcceptVisitor(visitor);
WhenTrue.AcceptVisitor(visitor);
WhenFalse.AcceptVisitor(visitor);
}
public override void AcceptVisitor(StatementVisitor visitor)
{
visitor.VisitReferenceToTypeMember(TypeOperand);
}
public override MemberDeclarationSyntax VisitForClass(ConversionContext context, ClassDeclarationSyntax classSyntax, MethodDeclaration methodDecl)
{
var returnType = methodDecl.getType();
var returnTypeName = TypeHelper.ConvertType(returnType.toString());
var methodName = TypeHelper.Capitalize(methodDecl.getName());
methodName = TypeHelper.ReplaceCommonMethodNames(methodName);
var methodSyntax = SyntaxFactory.MethodDeclaration(SyntaxFactory.ParseTypeName(returnTypeName), methodName);
// TODO: Call methodDecl.getTypeParameters() to see if the method is generic
var mods = methodDecl.getModifiers();
if (mods.HasFlag(Modifier.PUBLIC))
{
methodSyntax = methodSyntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword));
}
if (mods.HasFlag(Modifier.PROTECTED))
{
methodSyntax = methodSyntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.ProtectedKeyword));
}
if (mods.HasFlag(Modifier.PRIVATE))
{
methodSyntax = methodSyntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.PrivateKeyword));
}
if (mods.HasFlag(Modifier.STATIC))
{
methodSyntax = methodSyntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.StaticKeyword));
}
if (mods.HasFlag(Modifier.ABSTRACT))
{
methodSyntax = methodSyntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.AbstractKeyword));
}
var annotations = methodDecl.getAnnotations().ToList <AnnotationExpr>();
bool isOverride = false;
// TODO: figure out how to check for a non-interface base type
if (annotations != null &&
annotations.Count > 0)
{
foreach (var annotation in annotations)
{
string name = annotation.getName().getName();
if (name == "Override")
{
methodSyntax = methodSyntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.OverrideKeyword));
isOverride = true;
}
}
}
if (!mods.HasFlag(Modifier.FINAL) &&
!mods.HasFlag(Modifier.ABSTRACT) &&
!mods.HasFlag(Modifier.STATIC) &&
!mods.HasFlag(Modifier.PRIVATE) &&
!isOverride &&
!classSyntax.Modifiers.Any(i => i.Kind() == SyntaxKind.SealedKeyword))
{
methodSyntax = methodSyntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.VirtualKeyword));
}
var parameters = methodDecl.getParameters().ToList <Parameter>();
if (parameters != null && parameters.Count > 0)
{
var paramSyntaxes = new List <ParameterSyntax>();
foreach (var param in parameters)
{
string typeName = TypeHelper.ConvertType(param.getType().toString());
string identifier = TypeHelper.ConvertIdentifierName(param.getId().getName());
if ((param.getId().getArrayCount() > 0 && !typeName.EndsWith("[]")) || param.isVarArgs())
{
typeName += "[]";
}
SyntaxTokenList modifiers = SyntaxFactory.TokenList();
if (param.isVarArgs())
{
modifiers = SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ParamsKeyword));
}
var paramSyntax = SyntaxFactory.Parameter(attributeLists: SyntaxFactory.List <AttributeListSyntax>(),
modifiers: modifiers,
type: SyntaxFactory.ParseTypeName(typeName),
identifier: SyntaxFactory.ParseToken(identifier),
@default: null);
paramSyntaxes.Add(paramSyntax);
}
methodSyntax = methodSyntax.AddParameterListParameters(paramSyntaxes.ToArray());
}
var block = methodDecl.getBody();
if (block == null)
{
// i.e. abstract method
methodSyntax = methodSyntax.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));
return(methodSyntax.AddComment(context, methodDecl));
}
var statements = block.getStmts().ToList <Statement>();
var statementSyntax = StatementVisitor.VisitStatements(context, statements);
// Look for comments at the end of the method body
var trailingComments = block
.getChildrenNodes().AsEnumerable <Node>()
.OrderByDescending(n => n.getBeginLine()).ThenByDescending(n => n.getBeginColumn())
.TakeWhile(n => n is Comment)
.Cast <Comment>()
.Reverse()
.Select(cmt => SyntaxFactory.Comment(cmt.toString().TrimEnd('\r', '\n')));
if (mods.HasFlag(Modifier.SYNCHRONIZED))
{
LockStatementSyntax lockSyntax;
BlockSyntax lockBlock = SyntaxFactory.Block(statementSyntax);
if (mods.HasFlag(Modifier.STATIC))
{
lockSyntax = SyntaxFactory.LockStatement(SyntaxFactory.TypeOfExpression(SyntaxFactory.ParseTypeName(classSyntax.Identifier.Value.ToString())), lockBlock);
}
else
{
lockSyntax = SyntaxFactory.LockStatement(SyntaxFactory.ThisExpression(), lockBlock);
}
methodSyntax = methodSyntax.AddBodyStatements(lockSyntax);
}
else
{
methodSyntax = methodSyntax.AddBodyStatements(statementSyntax.ToArray());
}
// Add any trailing comments before the closing bracket
var closeBraceToken = methodSyntax.Body.CloseBraceToken
.WithLeadingTrivia(trailingComments);
methodSyntax = methodSyntax.ReplaceNode(methodSyntax.Body,
methodSyntax.Body.WithCloseBraceToken(closeBraceToken));
return(methodSyntax.AddComment(context, methodDecl));
// Trailing
}
public override void AcceptVisitor(StatementVisitor visitor)
{
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public override void AcceptVisitor(StatementVisitor visitor)
{
visitor.VisitAnonymousDelegateExpression(this);
Body.AcceptVisitor(visitor);
}
public override T AcceptVisitor <T, C>(StatementVisitor <T, C> visitor, C context)
{
return(visitor.VisitIfStatement(this, context));
}
public override MemberDeclarationSyntax VisitForClass(ConversionContext context, ClassDeclarationSyntax classSyntax, MethodDeclaration methodDecl)
{
var returnType = methodDecl.getType();
var returnTypeName = TypeHelper.ConvertType(returnType.toString());
var methodName = TypeHelper.Capitalize(methodDecl.getName());
methodName = TypeHelper.ReplaceCommonMethodNames(methodName);
var methodSyntax = SyntaxFactory.MethodDeclaration(SyntaxFactory.ParseTypeName(returnTypeName), methodName);
var mods = methodDecl.getModifiers();
if (mods.HasFlag(Modifier.PUBLIC))
{
methodSyntax = methodSyntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword));
}
if (mods.HasFlag(Modifier.PROTECTED))
{
methodSyntax = methodSyntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.ProtectedKeyword));
}
if (mods.HasFlag(Modifier.PRIVATE))
{
methodSyntax = methodSyntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.PrivateKeyword));
}
if (mods.HasFlag(Modifier.STATIC))
{
methodSyntax = methodSyntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.StaticKeyword));
}
if (mods.HasFlag(Modifier.ABSTRACT))
{
methodSyntax = methodSyntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.AbstractKeyword));
}
var annotations = methodDecl.getAnnotations().ToList <AnnotationExpr>();
bool isOverride = false;
// TODO: figure out how to check for a non-interface base type
if (annotations != null &&
annotations.Count > 0)
{
foreach (var annotation in annotations)
{
string name = annotation.getName().getName();
if (name == "Override")
{
methodSyntax = methodSyntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.OverrideKeyword));
isOverride = true;
}
}
}
if (!mods.HasFlag(Modifier.FINAL) &&
!mods.HasFlag(Modifier.ABSTRACT) &&
!mods.HasFlag(Modifier.STATIC) &&
!mods.HasFlag(Modifier.PRIVATE) &&
!isOverride &&
!classSyntax.Modifiers.Any(i => i.Kind() == SyntaxKind.SealedKeyword))
{
methodSyntax = methodSyntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.VirtualKeyword));
}
var parameters = methodDecl.getParameters().ToList <Parameter>();
if (parameters != null && parameters.Count > 0)
{
var paramSyntaxes = new List <ParameterSyntax>();
foreach (var param in parameters)
{
string typeName = TypeHelper.ConvertType(param.getType().toString());
string identifier = TypeHelper.ConvertIdentifierName(param.getId().getName());
if ((param.getId().getArrayCount() > 0 && !typeName.EndsWith("[]")) || param.isVarArgs())
{
typeName += "[]";
}
SyntaxTokenList modifiers = SyntaxFactory.TokenList();
if (param.isVarArgs())
{
modifiers = SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ParamsKeyword));
}
var paramSyntax = SyntaxFactory.Parameter(
attributeLists: new SyntaxList <AttributeListSyntax>(),
modifiers: modifiers,
type: SyntaxFactory.ParseTypeName(typeName),
identifier: SyntaxFactory.ParseToken(identifier),
@default: null);
paramSyntaxes.Add(paramSyntax);
}
methodSyntax = methodSyntax.AddParameterListParameters(paramSyntaxes.ToArray());
}
var block = methodDecl.getBody();
if (block == null)
{
// i.e. abstract method
methodSyntax = methodSyntax.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));
return(methodSyntax);
}
var statements = block.getStmts().ToList <Statement>();
var statementSyntax = StatementVisitor.VisitStatements(context, statements);
if (mods.HasFlag(Modifier.SYNCHRONIZED))
{
LockStatementSyntax lockSyntax;
BlockSyntax lockBlock = SyntaxFactory.Block(statementSyntax);
if (mods.HasFlag(Modifier.STATIC))
{
lockSyntax = SyntaxFactory.LockStatement(SyntaxFactory.TypeOfExpression(SyntaxFactory.ParseTypeName(classSyntax.Identifier.Value.ToString())), lockBlock);
}
else
{
lockSyntax = SyntaxFactory.LockStatement(SyntaxFactory.ThisExpression(), lockBlock);
}
methodSyntax = methodSyntax.AddBodyStatements(lockSyntax);
}
else
{
methodSyntax = methodSyntax.AddBodyStatements(statementSyntax.ToArray());
}
return(methodSyntax);
}
///////////////////////////////////////////////////////////////////
public override Statement visit(StatementVisitor v)
{
return(v.visit(this));
}
public override void AcceptVisitor(StatementVisitor visitor)
{
visitor.VisitReThrowStatement(this);
}
public override void Accept(StatementVisitor vis)
{
vis.Visit(this);
}
public abstract R Accept <R>(StatementVisitor <R> vis);
public override void Visit(StatementVisitor visitor)
{
visitor.Visit(this);
}
public override void visit(StatementVisitor visitor)
{
visitor.visit_trycatch(this);
}