ULNode ExportExp(ThisExpressionSyntax e)
{
ULNode node = ULNode.NewControlNode(ULNode.name_getthis);
graph.Nodes.Add(node);
return(node);
}
public override void VisitThisExpression(ThisExpressionSyntax node)
{
switch (node.Parent.Kind())
{
case SyntaxKind.Argument:
return;
}
switch (this.UsesThis)
{
case Result.Unknown:
this.UsesThis = Result.Yes;
break;
case Result.Yes:
break;
case Result.No:
this.UsesThis = Result.Maybe;
break;
case Result.Maybe:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public override SyntaxNode VisitThisExpression(ThisExpressionSyntax node)
{
if (IsRoleMethod)
{
return RewriteRoleExpression(node);
}
return base.VisitThisExpression(node);
}
public override void VisitThisExpression(ThisExpressionSyntax node)
{
cancellationToken.ThrowIfCancellationRequested();
NodesToChange.Add(node);
base.VisitThisExpression(node);
}
public override SyntaxNode VisitThisExpression(ThisExpressionSyntax node)
{
// Considers:
// this.a.b.c -> newParameter.a.b.c
return(Syntax.IdentifierName(this.newParameterNameToken)
.WithLeadingTrivia(node.GetLeadingTrivia())
.WithTrailingTrivia(node.GetTrailingTrivia()));
}
public override SyntaxNode VisitThisExpression(ThisExpressionSyntax node)
{
if (IsRoleMethod)
{
return(RewriteRoleExpression(node));
}
return(base.VisitThisExpression(node));
}
public override void VisitThisExpression(ThisExpressionSyntax thisSyntax)
{
var type = this.Context.SemanticModel.GetTypeInfo(thisSyntax).Type;
var valueModel = this.Context.GetLocalInstanceModel(type);
Contract.Assert(this.Context.CurrentNode.ValueModel == null);
this.Context.CurrentNode.ValueModel = valueModel;
}
// Not really strictly needed since the compiler for the normal C# will yell at people for us if they attempt to access something not valid for `this`
public override void VisitThisExpression(ThisExpressionSyntax node)
{
UpdateSyntaxNode(node);
if (visitorContext.topCaptureScope != null)
{
visitorContext.topCaptureScope.ResolveAccessToken("this");
}
}
ULCall ExportExp(ThisExpressionSyntax e)
{
ULCall node = new ULCall();
node.Parent = currentBlock;
node.callType = ULCall.ECallType.GetThis;
//currentBlock.statements.Add(node);
return(node);
}
public override IExpression VisitThisExpression(ThisExpressionSyntax node)
{
var o = this.semanticModel.GetTypeInfo(node);
return(new ThisReference()
{
Type = this.mapper.Map(o.Type),
});
}
public override void VisitThisExpression(ThisExpressionSyntax node)
{
if (!PreVisit(node))
{
return;
}
base.VisitThisExpression(node);
PostVisit(node);
}
void AnalyzeThis(ThisExpressionSyntax thisExpression)
{
// Indexer case.
if (thisExpression.Parent is ElementAccessExpressionSyntax elementAccess &&
elementAccess.Expression == thisExpression)
{
var indexer = MemberMap.Properties.Values.FirstOrDefault(p => p.Symbol.IsIndexer);
if (indexer != null)
{
AnalyzeProperty(indexer, elementAccess.IsAssigned());
}
}
}
public override TempComputeResult VisitThisExpression(ThisExpressionSyntax node)
{
VariableReferenceTuple tuple;
if (dic_Expression_Variable.TryGetValue(node, out tuple))
{
return(ResolveVariable(tuple.Bottom));
}
ILMethod currentMethod;
var v = DebugService.GetThis(Intepreter, 0, out currentMethod);
return(CreateComputeResult(v, currentMethod.DeclearingType.ReflectionType));
}
/// <summary>
/// Rewrites the expression with a this expression.
/// </summary>
private SyntaxNode RewriteExpression(ThisExpressionSyntax node)
{
SyntaxNode rewritten = node;
if (rewritten.Parent is ArgumentSyntax ||
(rewritten.Parent is AssignmentExpressionSyntax &&
(rewritten.Parent as AssignmentExpressionSyntax).Right.IsEquivalentTo(node)))
{
var text = "this.Id";
this.Program.AddRewrittenTerm(node, text);
rewritten = SyntaxFactory.ParseExpression(text).WithTriviaFrom(node);
}
return(rewritten);
}
/// <summary>
/// Rewrites the expression with a this expression.
/// </summary>
/// <param name="node">ThisExpressionSyntax</param>
/// <returns>SyntaxNode</returns>
private SyntaxNode RewriteExpression(ThisExpressionSyntax node)
{
SyntaxNode rewritten = node;
if (rewritten.Parent is ArgumentSyntax ||
(rewritten.Parent is AssignmentExpressionSyntax &&
(rewritten.Parent as AssignmentExpressionSyntax).Right.IsEquivalentTo(node)))
{
var text = "this.Id";
rewritten = SyntaxFactory.ParseExpression(text);
rewritten = rewritten.WithTriviaFrom(node);
}
return rewritten;
}
/// <summary>
/// Rewrites the expression with a this expression.
/// </summary>
/// <param name="node">ThisExpressionSyntax</param>
/// <returns>SyntaxNode</returns>
private SyntaxNode RewriteExpression(ThisExpressionSyntax node)
{
SyntaxNode rewritten = node;
MachineDeclaration machine = null;
if (!base.TryGetParentMachine(rewritten, out machine))
{
return(rewritten);
}
var isMonitor = base.IsMonitor(machine.Identifier.TextUnit.Text);
if (!isMonitor && (rewritten.Parent is ArgumentSyntax ||
(rewritten.Parent is AssignmentExpressionSyntax &&
(rewritten.Parent as AssignmentExpressionSyntax).Right.IsEquivalentTo(node))))
{
var text = "this.Id";
rewritten = SyntaxFactory.ParseExpression(text);
rewritten = rewritten.WithTriviaFrom(node);
}
else if (rewritten.Parent is MemberAccessExpressionSyntax &&
base.IsInStateScope(rewritten) &&
(base.IsMachineField((rewritten.Parent as MemberAccessExpressionSyntax).Name) ||
base.IsMachineMethod((rewritten.Parent as MemberAccessExpressionSyntax).Name)))
{
var text = "(";
if (isMonitor)
{
text += "this.Monitor";
}
else
{
text += "this.Machine";
}
text += " as " + machine.Identifier.TextUnit.Text + ")";
rewritten = SyntaxFactory.ParseExpression(text);
rewritten = rewritten.WithTriviaFrom(node);
}
return(rewritten);
}
/// <summary>
/// Rewrites the expression with a this expression.
/// </summary>
/// <param name="node">ThisExpressionSyntax</param>
/// <returns>SyntaxNode</returns>
private SyntaxNode RewriteExpression(ThisExpressionSyntax node)
{
SyntaxNode rewritten = node;
MachineDeclaration machine = null;
if (!base.TryGetParentMachine(rewritten, out machine))
{
return rewritten;
}
var isMonitor = base.IsMonitor(machine.Identifier.TextUnit.Text);
if (!isMonitor && (rewritten.Parent is ArgumentSyntax ||
(rewritten.Parent is AssignmentExpressionSyntax &&
(rewritten.Parent as AssignmentExpressionSyntax).Right.IsEquivalentTo(node))))
{
var text = "this.Id";
rewritten = SyntaxFactory.ParseExpression(text);
rewritten = rewritten.WithTriviaFrom(node);
}
else if (rewritten.Parent is MemberAccessExpressionSyntax &&
base.IsInStateScope(rewritten) &&
(base.IsMachineField((rewritten.Parent as MemberAccessExpressionSyntax).Name) ||
base.IsMachineMethod((rewritten.Parent as MemberAccessExpressionSyntax).Name)))
{
var text = "(";
if (isMonitor)
{
text += "this.Monitor";
}
else
{
text += "this.Machine";
}
text += " as " + machine.Identifier.TextUnit.Text + ")";
rewritten = SyntaxFactory.ParseExpression(text);
rewritten = rewritten.WithTriviaFrom(node);
}
return rewritten;
}
public override void VisitThisExpression(ThisExpressionSyntax node)
{
switch (this.UsesThis)
{
case Result.Unknown:
this.UsesThis = Result.Yes;
break;
case Result.Yes:
break;
case Result.No:
this.UsesThis = Result.Maybe;
break;
case Result.Maybe:
break;
default:
throw new ArgumentOutOfRangeException();
}
base.VisitThisExpression(node);
}
public override SyntaxNode VisitThisExpression(ThisExpressionSyntax node)
{
_output.Write(node, "this");
return node;
}
public override void VisitThisExpression(ThisExpressionSyntax node)
{
throw new NotImplementedException();
}
public static void Go(ScalaWriter writer, ThisExpressionSyntax expression)
{
writer.Write("this");
}
public TameThisExpressionSyntax(ThisExpressionSyntax node)
{
Node = node;
AddChildren();
}
public static ThisExpressionSyntax ThisExpression()
{
var result = new ThisExpressionSyntax();
return result;
}
public static void Go(OutputWriter writer, ThisExpressionSyntax expression)
{
writer.Write("this");
}
public override void VisitThisExpression(ThisExpressionSyntax node)
{
Writer.WriteJsRawValue("this");
}
/// <summary>
/// thisのTypeScript変換
/// </summary>
/// <param name="condition">ExpressionSyntaxインスタンス</param>
/// <param name="localDeclarationStatements">ローカル変数リスト</param>
/// <returns>TypeScriptに変換した文字列</returns>
private string ConvertExpression(ThisExpressionSyntax condition, List <string> localDeclarationStatements)
{
return(condition.ToString());
}
public void VisitThisExpression(ThisExpressionSyntax node)
{
if (node == null)
throw new ArgumentNullException("node");
node.Validate();
ExpressionStart(node);
_writer.WriteKeyword(PrinterKeyword.This);
ExpressionEnd(node);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitThisExpression(ThisExpressionSyntax node)
{
this.OnNodeVisited(node);
if (!this.traverseRootOnly) base.VisitThisExpression(node);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitThisExpression(ThisExpressionSyntax node)
{
this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
base.VisitThisExpression(node);
}
public virtual void VisitThisExpression(ThisExpressionSyntax node) => DefaultVisit(node);
public override Evaluation VisitThisExpression(ThisExpressionSyntax node)
{
return(base.VisitThisExpression(node));
}
private HybInstance ResolveThis(ThisExpressionSyntax node)
{
return(Ctx._this);
}
public override SyntaxNode VisitThisExpression(ThisExpressionSyntax node)
{
_output.Write(node, "this");
return(node);
}
private static SyntaxNode GenerateReplacementNode(ThisExpressionSyntax node)
{
var parent = (MemberAccessExpressionSyntax)node.Parent;
return parent.Name.WithTriviaFrom(parent);
}
public virtual void VisitThisExpression(ThisExpressionSyntax node)
{
DefaultVisit(node);
}
public ThisExpressionTranslation(ThisExpressionSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
}
public static void Write(ThisExpressionSyntax syntax, IIndentedTextWriterWrapper textWriter, IContext context)
{
textWriter.Write("element");
}
private string GenerateThisExpression(ThisExpressionSyntax thisExpressionSyntax, SemanticModel semanticModel)
{
return("this");
}
public override Ust VisitThisExpression(ThisExpressionSyntax node)
{
var result = new ThisReferenceToken(node.GetTextSpan());
return(result);
}
public override SyntaxNode VisitThisExpression(ThisExpressionSyntax node)
{
return(IdentifierName(SyntaxFactory.Identifier(ThisFieldName)));
}
private static SyntaxNode GenerateReplacementNode(ThisExpressionSyntax node)
{
var parent = (MemberAccessExpressionSyntax)node.Parent;
return(parent.Name.WithTriviaFrom(parent));
}
public override IStmt VisitThisExpression(ThisExpressionSyntax node)
{
return(new ThisExpr());
}
