private BaseBoundExpression BindExpression(BaseExpressionSyntax syntax, bool expectsValue = true)
{
switch (syntax)
{
case UnaryOperatorExpressionSyntax unaryOperatorExpression: return(this.BindUnaryOperatorExpression(unaryOperatorExpression));
case BinaryOperatorExpressionSyntax binaryOperatorExpression: return(this.BindBinaryOperatorExpression(binaryOperatorExpression));
case ArrayAccessExpressionSyntax arrayAccessExpression: return(this.BindArrayAccessExpression(arrayAccessExpression));
case ParenthesisExpressionSyntax parenthesisExpression: return(this.BindParenthesisExpression(parenthesisExpression));
case StringLiteralExpressionSyntax stringLiteralExpression: return(BindStringLiteralExpression(stringLiteralExpression));
case NumberLiteralExpressionSyntax numberLiteralExpression: return(this.BindNumberLiteralExpression(numberLiteralExpression));
case ObjectAccessExpressionSyntax objectAccessExpression: return(this.BindObjectAccessExpression(objectAccessExpression, expectsValue));
case InvocationExpressionSyntax invocationExpression: return(this.BindInvocationExpression(invocationExpression, expectsValue));
case IdentifierExpressionSyntax identifierExpression: return(this.BindIdentifierExpression(identifierExpression, expectsValue));
case UnrecognizedExpressionSyntax unrecognizedExpression: return(new BoundInvalidExpression(unrecognizedExpression, hasValue: true, hasErrors: true));
default: throw ExceptionUtilities.UnexpectedValue(syntax);
}
}
public BoundInvalidExpression(BaseExpressionSyntax syntax, bool hasValue, bool hasErrors)
: base(hasValue, hasErrors)
{
Debug.Assert(!syntax.IsDefault(), "'syntax' must not be null.");
this.Syntax = syntax;
}
ULCall ExportExp(BaseExpressionSyntax es)
{
var db_les = new ULCall();
db_les.Parent = currentBlock;
db_les.callType = ULCall.ECallType.GetBase;
//currentBlock.statements.Add(db_les);
return(db_les);
}
public override void VisitBaseExpression(BaseExpressionSyntax node)
{
if (!PreVisit(node))
{
return;
}
base.VisitBaseExpression(node);
PostVisit(node);
}
public override SyntaxNode VisitBaseExpression(BaseExpressionSyntax node)
{
if (string.IsNullOrEmpty(_template.BaseKeyword))
{
this.AppendCompileIssue(node, IssueType.Error, IssueId.BaseCallNotSupport);
}
else
{
_output.TrivialWrite(_template.BaseKeyword);
}
return(node);
}
public override LuaSyntaxNode VisitBaseExpression(BaseExpressionSyntax node)
{
var parent = (MemberAccessExpressionSyntax)node.Parent;
var symbol = semanticModel_.GetSymbolInfo(parent).Symbol;
bool hasBase = false;
switch (symbol.Kind)
{
case SymbolKind.Method: {
var methodSymbol = (IMethodSymbol)symbol;
if (IsBaseEnable(parent, methodSymbol, i => i.OverriddenMethod))
{
hasBase = true;
}
break;
}
case SymbolKind.Property: {
var propertySymbol = (IPropertySymbol)symbol;
if (!IsPropertyField(propertySymbol))
{
if (IsBaseEnable(parent, propertySymbol, i => i.OverriddenProperty))
{
hasBase = true;
}
}
break;
}
case SymbolKind.Event: {
var eventSymbol = (IEventSymbol)symbol;
if (!eventSymbol.IsEventFiled())
{
if (IsBaseEnable(parent, eventSymbol, i => i.OverriddenEvent))
{
hasBase = true;
}
}
break;
}
}
if (hasBase)
{
return(GetTypeName(symbol.ContainingType));
}
else
{
return(LuaIdentifierNameSyntax.This);
}
}
private List <ArgumentSyntax> ParseArguments()
{
var arguments = new List <ArgumentSyntax>();
BaseExpressionSyntax currentArgument = null;
while (this.index < this.tokens.Count)
{
if (!currentArgument.IsDefault())
{
switch (this.Peek())
{
case TokenKind.Comma:
var commaTokenOpt = this.Eat(TokenKind.Comma);
arguments.Add(new ArgumentSyntax(currentArgument, commaTokenOpt));
currentArgument = null;
break;
case TokenKind.RightParen:
arguments.Add(new ArgumentSyntax(currentArgument, commaTokenOpt: null));
return(arguments);
case TokenKind foundKind:
this.diagnostics.ReportUnexpectedTokenFound(this.tokens[this.index].Range, foundKind, TokenKind.Comma);
arguments.Add(new ArgumentSyntax(currentArgument, commaTokenOpt: null));
currentArgument = null;
break;
}
}
else if (this.Peek() == TokenKind.RightParen)
{
return(arguments);
}
else
{
currentArgument = this.ParseBaseExpression();
}
}
if (!currentArgument.IsDefault())
{
arguments.Add(new ArgumentSyntax(currentArgument, commaTokenOpt: null));
}
return(arguments);
}
internal static InvocationExpressionSyntax BuildBaseInvocationExpr(this IMethodSymbol @this,
BaseExpressionSyntax baseExpr, string methodName)
{
InvocationExpressionSyntax invocationExpr;
if (@this.IsGenericMethod)
{
var typeParameters = @this.TypeParameters;
if (typeParameters.Length > 0)
{
var typeParameterList = BuildGeneric(typeParameters, IdentifierName);
var typeArgumentList = TypeArgumentList(SeparatedList <TypeSyntax>(typeParameterList));
invocationExpr = InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
baseExpr,
GenericName(Identifier(methodName))
.WithTypeArgumentList(typeArgumentList)));
}
else
{
invocationExpr = InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
baseExpr,
GenericName(Identifier(methodName))));
}
}
else
{
invocationExpr = InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
baseExpr,
IdentifierName(methodName)));
}
return(invocationExpr);
}
public override IStmt VisitBaseExpression(BaseExpressionSyntax node)
{
return(new BaseExpr());
}
/// <summary>
/// baseのTypeScript変換
/// </summary>
/// <param name="condition">ExpressionSyntaxインスタンス</param>
/// <param name="localDeclarationStatements">ローカル変数リスト</param>
/// <returns>TypeScriptに変換した文字列</returns>
private string ConvertExpression(BaseExpressionSyntax condition, List <string> localDeclarationStatements)
{
return("super");
}
public static void Go(OutputWriter writer, BaseExpressionSyntax expression)
{
var baseType = TypeProcessor.GetTypeInfo(expression).Type;
writer.Write("super");
}
public BaseExpressionTranslation(BaseExpressionSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
}
public BaseExpressionTranslation(BaseExpressionSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
}
public override void VisitBaseExpression(BaseExpressionSyntax node)
{
throw new NotImplementedException();
}
public override Evaluation VisitBaseExpression(BaseExpressionSyntax node)
{
return(base.VisitBaseExpression(node));
}
public override SyntaxNode VisitBaseExpression(BaseExpressionSyntax node)
{
node = (BaseExpressionSyntax)base.VisitBaseExpression(node);
Classes.Add(node);
return(node);
}
public static BaseExpressionSyntax BaseExpression()
{
var result = new BaseExpressionSyntax();
return result;
}
public override void VisitBaseExpression(BaseExpressionSyntax node)
{
Emit <BaseExpressionBlock, BaseExpressionSyntax>(node);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitBaseExpression(BaseExpressionSyntax node)
{
this.OnNodeVisited(node);
if (!this.traverseRootOnly) base.VisitBaseExpression(node);
}
private Doc PrintBaseExpressionSyntax(BaseExpressionSyntax node)
{
return(this.PrintSyntaxToken(node.Token));
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitBaseExpression(BaseExpressionSyntax node)
{
this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
base.VisitBaseExpression(node);
}
public void VisitBaseExpression(BaseExpressionSyntax node)
{
if (node == null)
throw new ArgumentNullException("node");
node.Validate();
_writer.WriteKeyword(PrinterKeyword.Base);
}
// base表达式
public virtual void VisitBaseExpressionSyntax(BaseExpressionSyntax value)
{
DefaultVisit(value);
}
public override void VisitBaseExpression(BaseExpressionSyntax syntax)
{
_usesThis = true;
}
public virtual void VisitBaseExpression(BaseExpressionSyntax node)
{
DefaultVisit(node);
}
public static Doc Print(BaseExpressionSyntax node)
{
return(Token.Print(node.Token));
}
public override SyntaxNode VisitBaseExpression(BaseExpressionSyntax node)
{
if (string.IsNullOrEmpty(_template.BaseKeyword))
this.AppendCompileIssue(node, IssueType.Error, IssueId.BaseCallNotSupport);
else
_output.TrivialWrite(_template.BaseKeyword);
return node;
}
public override void VisitBaseExpression(BaseExpressionSyntax node)
{
base.VisitBaseExpression(node);
}
public static string BaseExpression(BaseExpressionSyntax expression)
{
return "super";
}
// // Summary: // Called when the visitor visits a BaseExpressionSyntax node. public virtual void VisitBaseExpression(BaseExpressionSyntax node);
public override IEnumerable <IModel> VisitBaseExpression(BaseExpressionSyntax node)
{
yield return(Create <BaseExpression>(node));
}
public static void Go(HaxeWriter writer, BaseExpressionSyntax expression)
{
writer.Write("super");
}
private static ThisExpressionSyntax RewriteBaseAsThis(BaseExpressionSyntax token)
{
return(SyntaxFactory.ThisExpression(SyntaxFactory.Token(SyntaxKind.ThisKeyword).WithTriviaFrom(token.Token)));
}
public override void VisitBaseExpression(BaseExpressionSyntax node)
{
CodeBuilder.Append("this.base");
}
public static void Write(this BaseExpressionSyntax syntax, IIndentedTextWriterWrapper textWriter, IContext context)
{
textWriter.Write("element");
}
public TameBaseExpressionSyntax(BaseExpressionSyntax node)
{
Node = node;
AddChildren();
}
public override void VisitBaseExpression(BaseExpressionSyntax node)
{
base.VisitBaseExpression(node);
}
public virtual void VisitBaseExpression(BaseExpressionSyntax baseExpression, A args)
{
}
public static string BaseExpression(BaseExpressionSyntax expression)
{
return("super");
}
public override Ust VisitBaseExpression(BaseExpressionSyntax node)
{
var result = new BaseReferenceToken(node.GetTextSpan());
return(result);
}
