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 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 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); }