private void Visit( MemberAccessExpression expression, QualifiedModuleName module, Declaration scope, Declaration parent, bool isAssignmentTarget, bool hasExplicitLetStatement, bool isSetAssignment) { Visit(expression.LExpression, module, scope, parent); // Expressions could be unbound thus not have a referenced declaration. The lexpression might still be bindable though. if (expression.Classification == ExpressionClassification.Unbound) { return; } var callSiteContext = expression.UnrestrictedNameContext; var callee = expression.ReferencedDeclaration; var identifier = WithEnclosingBracketsRemoved(callSiteContext.GetText()); var selection = callSiteContext.GetSelection(); expression.ReferencedDeclaration.AddReference( module, scope, parent, callSiteContext, identifier, callee, selection, FindIdentifierAnnotations(module, selection.StartLine), isAssignmentTarget, hasExplicitLetStatement, isSetAssignment); }
/// <summary> /// Fixes the error. /// </summary> /// <param name="violationContext">Context for the violation.</param> /// <param name="token">The token that is missing a prefix.</param> private void FixPrefixLocalCallsWithThisViolation(ViolationContext violationContext, Token token) { Param.Ignore(violationContext); Param.AssertNotNull(token, "token"); CsDocument document = token.Document; // Find the item that is going to get replaced. CodeUnit itemToReplace = token; LiteralExpression parent = token.Parent as LiteralExpression; if (parent != null) { itemToReplace = parent; } // Record the location of this item. CodeUnitLocationMarker marker = document.GetCodeUnitLocationMarker(itemToReplace); // If the token is not already wrapped by a literal expression, create one. LiteralExpression rightHandSide = parent; if (rightHandSide == null) { rightHandSide = document.CreateLiteralExpression(token); } // Create the left-hand side and the expression. LiteralExpression leftHandSide = document.CreateLiteralExpression(document.CreateThisToken()); MemberAccessExpression expression = document.CreateMemberAccessExpression(leftHandSide, rightHandSide); // Insert the member access expression in the same location as the previous literal. document.Insert(expression, marker); }
private object VisitMemberAccess(MemberAccessExpression memAccess) { var obj = Visit(memAccess.Object); if (obj == null) { throw Error($"null reference to '{memAccess.Object}'"); } var type = obj.GetType(); var prop = type.GetProperty(memAccess.MemberName); if (prop != null) { return(prop.GetValue(obj)); } var field = type.GetField(memAccess.MemberName); if (field != null) { return(field.GetValue(obj)); } var method = type.GetMethod(memAccess.MemberName); if (method != null) { return(method); } throw Error($"field or property '{memAccess.MemberName}' not found"); }
private void Visit( MemberAccessExpression expression, QualifiedModuleName module, Declaration scope, Declaration parent, bool isAssignmentTarget, bool hasExplicitLetStatement) { Visit((dynamic)expression.LExpression, module, scope, parent, false, false); // Expressions could be unbound thus not have a referenced declaration. The lexpression might still be bindable though. if (expression.Classification != ExpressionClassification.Unbound) { var callSiteContext = expression.UnrestrictedNameContext; var identifier = expression.UnrestrictedNameContext.GetText(); var callee = expression.ReferencedDeclaration; expression.ReferencedDeclaration.AddReference( module, scope, parent, callSiteContext, identifier, callee, callSiteContext.GetSelection(), _annotationService.FindAnnotations(module, callSiteContext.GetSelection().StartLine), isAssignmentTarget, hasExplicitLetStatement); } }
public virtual bool VisitMemberAccessExpression(MemberAccessExpression accessExpression) { VisitNode(accessExpression.Target); VisitExpression(accessExpression); return(true); }
protected override Expression VisitMemberAccessExpression(MemberAccessExpression expression) { var nm = Utility.PascalCase(expression.Name); return(Expression.MemberAccess(this.Visit(expression.Expression), nm)); }
internal MemberInvocationExpressionInfo WithName(string name) { MemberAccessExpressionSyntax newMemberAccess = MemberAccessExpression.WithName(SyntaxFactory.IdentifierName(name).WithTriviaFrom(Name)); InvocationExpressionSyntax newInvocation = InvocationExpression.WithExpression(newMemberAccess); return(new MemberInvocationExpressionInfo(newMemberAccess.Expression, newMemberAccess.Name, newInvocation.ArgumentList)); }
protected override object VisitMemberAccessExpression(MemberAccessExpressionSyntax node) { var name = _Name(node.Name).GetNonGeneric(); var expression = _VisitExpression(node.Expression); IValue TMP = new MemberAccessExpression(name, expression); return(_OptimizeIValue(TMP)); }
public override void VisitMemberAccessExpression(MemberAccessExpression accessExpression) { nodeStack.Push(CurrentNode.Nodes.Add("MemberAccessExpression [" + accessExpression.Name + " ] ")); CurrentNode.Tag = accessExpression; base.VisitMemberAccessExpression(accessExpression); nodeStack.Pop(); }
public override bool VisitMemberAccessExpression(MemberAccessExpression accessExpression) { nodeStack.Push(CurrentNode.Nodes.Add("MemberAccessExpression " + accessExpression.Member)); CurrentNode.Tag = accessExpression; CurrentNode.EnsureVisible(); base.VisitMemberAccessExpression(accessExpression); nodeStack.Pop(); return(true); }
///////////////////////////////////////////////////////////////////////////// public override object EvalMemberAccessExpression( object objIn, MemberAccessExpression exp ) { // ****** // // expression: macro.member // // look up member name and return the object it references // object objResult = null; var invoker = objIn as Invoker; if( null != invoker ) { objResult = invoker.Invoke(); } else { objResult = Invokers.EvalMemberHelper( objIn, exp.MemberName, typeHelpers ); } // ****** CheckNullResult( objResult, objIn, exp.MemberName ); return objResult; }
private System.Linq.Expressions.Expression EvaluateMemberAccessExpression(MemberAccessExpression memberAccessExpression) { var targetExpression = Evaluate(memberAccessExpression.Target); switch (memberAccessExpression.Member) { case FunctionCallExpression functionCallExpression: return(System.Linq.Expressions.Expression.Call( targetExpression, targetExpression.Type.GetMethod(functionCallExpression.Name), functionCallExpression.Arguments.Select(Evaluate) )); break; case VariableExpression variableExpression: return(System.Linq.Expressions.Expression.MakeMemberAccess( targetExpression, targetExpression.Type.GetProperty(variableExpression.Name) )); } return(null); }
private Expression DoExpression(bool doOperator = true) { Expression ret = null; if (Take(LexemeKind.LeftParenthesis, out _)) { ret = DoExpression(); if (Take(LexemeKind.QuestionMark, out _)) { ret = DoTernaryOperator(ret); } Take(LexemeKind.RightParenthesis, "closing parentheses"); } else if (Take(LexemeKind.String, out var str)) { if (float.TryParse(str.Content, NumberStyles.Float, CultureInfo.InvariantCulture, out var f)) { ret = new NumberLiteralExpression(f); } else if (Current.Kind == LexemeKind.Exclamation) { ret = DoFunctionCall(str.Content); } else { if (Current.Kind == LexemeKind.LeftParenthesis) { ret = DoCommandExpression(str.Content); } else { Error($"unxpected string '{str.Content}' found"); } } } else if (Take(LexemeKind.QuotedString, out var quotedStr)) { ret = new StringLiteralExpression(quotedStr.Content); } else if (Take(LexemeKind.Exclamation, out _)) { ret = DoNegateOperator(); } else if (Take(LexemeKind.Keyword, out var keyword)) { if (keyword.Content == "null") { ret = new NullExpression(); } else if (keyword.Content == "true") { ret = new BooleanLiteralExpression(true); } else if (keyword.Content == "false") { ret = new BooleanLiteralExpression(false); } else { Error($"unexpected keyword: '{keyword.Content}'"); } } else if (Take(LexemeKind.Dollar, out _)) { Push(); if (Take(LexemeKind.String, out _) && Take(LexemeKind.EqualsAssign, out _)) { Pop(); ret = DoVariableAssign(); } else { Pop(); string name = Take(LexemeKind.String, "variable name").Content; ret = new VariableAccessExpression(name); if (Take(LexemeKind.Increment, out _)) { ret = new UnaryOperatorExpression(Operator.IncrementByOne, ret); } else if (Take(LexemeKind.Decrement, out _)) { ret = new UnaryOperatorExpression(Operator.DecrementByOne, ret); } } } while (Take(LexemeKind.Dot, out _)) { ret = new MemberAccessExpression(ret, Take(LexemeKind.String, "member name").Content); if (Take(LexemeKind.Exclamation, out _)) { ret = DoMemberCall(ret); } } if (ret != null && doOperator) { ret = Take(LexemeKind.QuestionMark, out _) ? DoTernaryOperator(ret) : (DoOperatorChain(ret) ?? ret); } return(ret); }
/// <summary> /// Reads a member access expression. /// </summary> /// <param name="leftSide">The left side of the expression.</param> /// <param name="previousPrecedence">The precedence of the previous expression.</param> /// <param name="unsafeCode">Indicates whether the code is marked as unsafe.</param> /// <returns>Returns the expression.</returns> private MemberAccessExpression GetMemberAccessExpression( Expression leftSide, ExpressionPrecedence previousPrecedence, bool unsafeCode) { Param.AssertNotNull(leftSide, "leftSide"); Param.Ignore(previousPrecedence); Param.Ignore(unsafeCode); MemberAccessExpression expression = null; OperatorType operatorType; MemberAccessExpression.Operator expressionOperatorType; ExpressionPrecedence precedence; // The next symbol must one of the member access types. Symbol symbol = this.GetNextSymbol(); if (symbol.SymbolType == SymbolType.Dot) { operatorType = OperatorType.MemberAccess; expressionOperatorType = MemberAccessExpression.Operator.Dot; precedence = ExpressionPrecedence.Primary; } else if (symbol.SymbolType == SymbolType.Pointer) { operatorType = OperatorType.Pointer; expressionOperatorType = MemberAccessExpression.Operator.Pointer; precedence = ExpressionPrecedence.Primary; } else if (symbol.SymbolType == SymbolType.QualifiedAlias) { operatorType = OperatorType.QualifiedAlias; expressionOperatorType = MemberAccessExpression.Operator.QualifiedAlias; precedence = ExpressionPrecedence.Global; } else { Debug.Fail("Unexpected operator type"); throw new InvalidOperationException(); } // Check the precedence. A member access has primary precedence. if (this.CheckPrecedence(previousPrecedence, precedence)) { // Add this to the document. this.tokens.Add(this.GetOperatorToken(operatorType)); // Get the member being accessed. This must be a literal. LiteralExpression member = this.GetLiteralExpression(unsafeCode); if (member == null) { throw this.CreateSyntaxException(); } // Create the token list. CsTokenList partialTokens = new CsTokenList(this.tokens, leftSide.Tokens.First, this.tokens.Last); // Create the expression. expression = new MemberAccessExpression(partialTokens, expressionOperatorType, leftSide, member); } return expression; }
public override bool VisitMemberAccessExpression(MemberAccessExpression accessExpression) { return(base.VisitMemberAccessExpression(accessExpression)); }
public virtual void VisitMemberAccessExpression(MemberAccessExpression accessExpression) { VisitNode(accessExpression.Inner); VisitCommonExpNodes(accessExpression); }
public static Doc Print(SyntaxNode syntaxNode) { if (syntaxNode == null) { return(Doc.Null); } // TODO 0 kill? runtime repo has files that will fail on deep recursion if (depth > 200) { throw new InTooDeepException(); } depth++; try { switch (syntaxNode) { case AliasQualifiedNameSyntax aliasQualifiedNameSyntax: return(AliasQualifiedName.Print(aliasQualifiedNameSyntax)); case AnonymousMethodExpressionSyntax anonymousMethodExpressionSyntax: return(AnonymousMethodExpression.Print(anonymousMethodExpressionSyntax)); case AnonymousObjectCreationExpressionSyntax anonymousObjectCreationExpressionSyntax: return(AnonymousObjectCreationExpression.Print( anonymousObjectCreationExpressionSyntax )); case AnonymousObjectMemberDeclaratorSyntax anonymousObjectMemberDeclaratorSyntax: return(AnonymousObjectMemberDeclarator.Print( anonymousObjectMemberDeclaratorSyntax )); case ArgumentListSyntax argumentListSyntax: return(ArgumentList.Print(argumentListSyntax)); case ArgumentSyntax argumentSyntax: return(Argument.Print(argumentSyntax)); case ArrayCreationExpressionSyntax arrayCreationExpressionSyntax: return(ArrayCreationExpression.Print(arrayCreationExpressionSyntax)); case ArrayRankSpecifierSyntax arrayRankSpecifierSyntax: return(ArrayRankSpecifier.Print(arrayRankSpecifierSyntax)); case ArrayTypeSyntax arrayTypeSyntax: return(ArrayType.Print(arrayTypeSyntax)); case ArrowExpressionClauseSyntax arrowExpressionClauseSyntax: return(ArrowExpressionClause.Print(arrowExpressionClauseSyntax)); case AssignmentExpressionSyntax assignmentExpressionSyntax: return(AssignmentExpression.Print(assignmentExpressionSyntax)); case AttributeListSyntax attributeListSyntax: return(AttributeList.Print(attributeListSyntax)); case AwaitExpressionSyntax awaitExpressionSyntax: return(AwaitExpression.Print(awaitExpressionSyntax)); case BaseExpressionSyntax baseExpressionSyntax: return(BaseExpression.Print(baseExpressionSyntax)); case BaseFieldDeclarationSyntax baseFieldDeclarationSyntax: return(BaseFieldDeclaration.Print(baseFieldDeclarationSyntax)); case BaseListSyntax baseListSyntax: return(BaseList.Print(baseListSyntax)); case BaseMethodDeclarationSyntax baseMethodDeclarationSyntax: return(BaseMethodDeclaration.Print(baseMethodDeclarationSyntax)); case BasePropertyDeclarationSyntax basePropertyDeclarationSyntax: return(BasePropertyDeclaration.Print(basePropertyDeclarationSyntax)); case BaseTypeDeclarationSyntax baseTypeDeclarationSyntax: return(BaseTypeDeclaration.Print(baseTypeDeclarationSyntax)); case BinaryExpressionSyntax binaryExpressionSyntax: return(BinaryExpression.Print(binaryExpressionSyntax)); case BinaryPatternSyntax binaryPatternSyntax: return(BinaryPattern.Print(binaryPatternSyntax)); case BlockSyntax blockSyntax: return(Block.Print(blockSyntax)); case BracketedArgumentListSyntax bracketedArgumentListSyntax: return(BracketedArgumentList.Print(bracketedArgumentListSyntax)); case BracketedParameterListSyntax bracketedParameterListSyntax: return(BracketedParameterList.Print(bracketedParameterListSyntax)); case BreakStatementSyntax breakStatementSyntax: return(BreakStatement.Print(breakStatementSyntax)); case CasePatternSwitchLabelSyntax casePatternSwitchLabelSyntax: return(CasePatternSwitchLabel.Print(casePatternSwitchLabelSyntax)); case CaseSwitchLabelSyntax caseSwitchLabelSyntax: return(CaseSwitchLabel.Print(caseSwitchLabelSyntax)); case CastExpressionSyntax castExpressionSyntax: return(CastExpression.Print(castExpressionSyntax)); case CatchClauseSyntax catchClauseSyntax: return(CatchClause.Print(catchClauseSyntax)); case CheckedExpressionSyntax checkedExpressionSyntax: return(CheckedExpression.Print(checkedExpressionSyntax)); case CheckedStatementSyntax checkedStatementSyntax: return(CheckedStatement.Print(checkedStatementSyntax)); case ClassOrStructConstraintSyntax classOrStructConstraintSyntax: return(ClassOrStructConstraint.Print(classOrStructConstraintSyntax)); case CompilationUnitSyntax compilationUnitSyntax: return(CompilationUnit.Print(compilationUnitSyntax)); case ConditionalAccessExpressionSyntax conditionalAccessExpressionSyntax: return(ConditionalAccessExpression.Print(conditionalAccessExpressionSyntax)); case ConditionalExpressionSyntax conditionalExpressionSyntax: return(ConditionalExpression.Print(conditionalExpressionSyntax)); case ConstantPatternSyntax constantPatternSyntax: return(ConstantPattern.Print(constantPatternSyntax)); case ConstructorConstraintSyntax constructorConstraintSyntax: return(ConstructorConstraint.Print(constructorConstraintSyntax)); case ConstructorInitializerSyntax constructorInitializerSyntax: return(ConstructorInitializer.Print(constructorInitializerSyntax)); case ContinueStatementSyntax continueStatementSyntax: return(ContinueStatement.Print(continueStatementSyntax)); case DeclarationExpressionSyntax declarationExpressionSyntax: return(DeclarationExpression.Print(declarationExpressionSyntax)); case DeclarationPatternSyntax declarationPatternSyntax: return(DeclarationPattern.Print(declarationPatternSyntax)); case DefaultConstraintSyntax defaultConstraintSyntax: return(DefaultConstraint.Print(defaultConstraintSyntax)); case DefaultExpressionSyntax defaultExpressionSyntax: return(DefaultExpression.Print(defaultExpressionSyntax)); case DefaultSwitchLabelSyntax defaultSwitchLabelSyntax: return(DefaultSwitchLabel.Print(defaultSwitchLabelSyntax)); case DelegateDeclarationSyntax delegateDeclarationSyntax: return(DelegateDeclaration.Print(delegateDeclarationSyntax)); case DiscardDesignationSyntax discardDesignationSyntax: return(DiscardDesignation.Print(discardDesignationSyntax)); case DiscardPatternSyntax discardPatternSyntax: return(DiscardPattern.Print(discardPatternSyntax)); case DoStatementSyntax doStatementSyntax: return(DoStatement.Print(doStatementSyntax)); case ElementAccessExpressionSyntax elementAccessExpressionSyntax: return(ElementAccessExpression.Print(elementAccessExpressionSyntax)); case ElementBindingExpressionSyntax elementBindingExpressionSyntax: return(ElementBindingExpression.Print(elementBindingExpressionSyntax)); case ElseClauseSyntax elseClauseSyntax: return(ElseClause.Print(elseClauseSyntax)); case EmptyStatementSyntax emptyStatementSyntax: return(EmptyStatement.Print(emptyStatementSyntax)); case EnumMemberDeclarationSyntax enumMemberDeclarationSyntax: return(EnumMemberDeclaration.Print(enumMemberDeclarationSyntax)); case EqualsValueClauseSyntax equalsValueClauseSyntax: return(EqualsValueClause.Print(equalsValueClauseSyntax)); case ExpressionStatementSyntax expressionStatementSyntax: return(ExpressionStatement.Print(expressionStatementSyntax)); case ExternAliasDirectiveSyntax externAliasDirectiveSyntax: return(ExternAliasDirective.Print(externAliasDirectiveSyntax)); case FinallyClauseSyntax finallyClauseSyntax: return(FinallyClause.Print(finallyClauseSyntax)); case FixedStatementSyntax fixedStatementSyntax: return(FixedStatement.Print(fixedStatementSyntax)); case ForEachStatementSyntax forEachStatementSyntax: return(ForEachStatement.Print(forEachStatementSyntax)); case ForEachVariableStatementSyntax forEachVariableStatementSyntax: return(ForEachVariableStatement.Print(forEachVariableStatementSyntax)); case ForStatementSyntax forStatementSyntax: return(ForStatement.Print(forStatementSyntax)); case FromClauseSyntax fromClauseSyntax: return(FromClause.Print(fromClauseSyntax)); case FunctionPointerTypeSyntax functionPointerTypeSyntax: return(FunctionPointerType.Print(functionPointerTypeSyntax)); case GenericNameSyntax genericNameSyntax: return(GenericName.Print(genericNameSyntax)); case GlobalStatementSyntax globalStatementSyntax: return(GlobalStatement.Print(globalStatementSyntax)); case GotoStatementSyntax gotoStatementSyntax: return(GotoStatement.Print(gotoStatementSyntax)); case GroupClauseSyntax groupClauseSyntax: return(GroupClause.Print(groupClauseSyntax)); case IdentifierNameSyntax identifierNameSyntax: return(IdentifierName.Print(identifierNameSyntax)); case IfStatementSyntax ifStatementSyntax: return(IfStatement.Print(ifStatementSyntax)); case ImplicitArrayCreationExpressionSyntax implicitArrayCreationExpressionSyntax: return(ImplicitArrayCreationExpression.Print( implicitArrayCreationExpressionSyntax )); case ImplicitElementAccessSyntax implicitElementAccessSyntax: return(ImplicitElementAccess.Print(implicitElementAccessSyntax)); case ImplicitObjectCreationExpressionSyntax implicitObjectCreationExpressionSyntax: return(ImplicitObjectCreationExpression.Print( implicitObjectCreationExpressionSyntax )); case ImplicitStackAllocArrayCreationExpressionSyntax implicitStackAllocArrayCreationExpressionSyntax: return(ImplicitStackAllocArrayCreationExpression.Print( implicitStackAllocArrayCreationExpressionSyntax )); case IncompleteMemberSyntax incompleteMemberSyntax: return(IncompleteMember.Print(incompleteMemberSyntax)); case InitializerExpressionSyntax initializerExpressionSyntax: return(InitializerExpression.Print(initializerExpressionSyntax)); case InterpolatedStringExpressionSyntax interpolatedStringExpressionSyntax: return(InterpolatedStringExpression.Print( interpolatedStringExpressionSyntax )); case InterpolatedStringTextSyntax interpolatedStringTextSyntax: return(InterpolatedStringText.Print(interpolatedStringTextSyntax)); case InterpolationSyntax interpolationSyntax: return(Interpolation.Print(interpolationSyntax)); case InvocationExpressionSyntax invocationExpressionSyntax: return(InvocationExpression.Print(invocationExpressionSyntax)); case IsPatternExpressionSyntax isPatternExpressionSyntax: return(IsPatternExpression.Print(isPatternExpressionSyntax)); case JoinClauseSyntax joinClauseSyntax: return(JoinClause.Print(joinClauseSyntax)); case LabeledStatementSyntax labeledStatementSyntax: return(LabeledStatement.Print(labeledStatementSyntax)); case LetClauseSyntax letClauseSyntax: return(LetClause.Print(letClauseSyntax)); case LiteralExpressionSyntax literalExpressionSyntax: return(LiteralExpression.Print(literalExpressionSyntax)); case LocalDeclarationStatementSyntax localDeclarationStatementSyntax: return(LocalDeclarationStatement.Print(localDeclarationStatementSyntax)); case LocalFunctionStatementSyntax localFunctionStatementSyntax: return(LocalFunctionStatement.Print(localFunctionStatementSyntax)); case LockStatementSyntax lockStatementSyntax: return(LockStatement.Print(lockStatementSyntax)); case MakeRefExpressionSyntax makeRefExpressionSyntax: return(MakeRefExpression.Print(makeRefExpressionSyntax)); case MemberAccessExpressionSyntax memberAccessExpressionSyntax: return(MemberAccessExpression.Print(memberAccessExpressionSyntax)); case MemberBindingExpressionSyntax memberBindingExpressionSyntax: return(MemberBindingExpression.Print(memberBindingExpressionSyntax)); case NameColonSyntax nameColonSyntax: return(NameColon.Print(nameColonSyntax)); case NameEqualsSyntax nameEqualsSyntax: return(NameEquals.Print(nameEqualsSyntax)); case NamespaceDeclarationSyntax namespaceDeclarationSyntax: return(NamespaceDeclaration.Print(namespaceDeclarationSyntax)); case NullableTypeSyntax nullableTypeSyntax: return(NullableType.Print(nullableTypeSyntax)); case ObjectCreationExpressionSyntax objectCreationExpressionSyntax: return(ObjectCreationExpression.Print(objectCreationExpressionSyntax)); case OmittedArraySizeExpressionSyntax omittedArraySizeExpressionSyntax: return(OmittedArraySizeExpression.Print(omittedArraySizeExpressionSyntax)); case OmittedTypeArgumentSyntax omittedTypeArgumentSyntax: return(OmittedTypeArgument.Print(omittedTypeArgumentSyntax)); case OrderByClauseSyntax orderByClauseSyntax: return(OrderByClause.Print(orderByClauseSyntax)); case ParameterListSyntax parameterListSyntax: return(ParameterList.Print(parameterListSyntax)); case ParameterSyntax parameterSyntax: return(Parameter.Print(parameterSyntax)); case ParenthesizedExpressionSyntax parenthesizedExpressionSyntax: return(ParenthesizedExpression.Print(parenthesizedExpressionSyntax)); case ParenthesizedLambdaExpressionSyntax parenthesizedLambdaExpressionSyntax: return(ParenthesizedLambdaExpression.Print( parenthesizedLambdaExpressionSyntax )); case ParenthesizedPatternSyntax parenthesizedPatternSyntax: return(ParenthesizedPattern.Print(parenthesizedPatternSyntax)); case ParenthesizedVariableDesignationSyntax parenthesizedVariableDesignationSyntax: return(ParenthesizedVariableDesignation.Print( parenthesizedVariableDesignationSyntax )); case PointerTypeSyntax pointerTypeSyntax: return(PointerType.Print(pointerTypeSyntax)); case PostfixUnaryExpressionSyntax postfixUnaryExpressionSyntax: return(PostfixUnaryExpression.Print(postfixUnaryExpressionSyntax)); case PredefinedTypeSyntax predefinedTypeSyntax: return(PredefinedType.Print(predefinedTypeSyntax)); case PrefixUnaryExpressionSyntax prefixUnaryExpressionSyntax: return(PrefixUnaryExpression.Print(prefixUnaryExpressionSyntax)); case PrimaryConstructorBaseTypeSyntax primaryConstructorBaseTypeSyntax: return(PrimaryConstructorBaseType.Print(primaryConstructorBaseTypeSyntax)); case QualifiedNameSyntax qualifiedNameSyntax: return(QualifiedName.Print(qualifiedNameSyntax)); case QueryBodySyntax queryBodySyntax: return(QueryBody.Print(queryBodySyntax)); case QueryContinuationSyntax queryContinuationSyntax: return(QueryContinuation.Print(queryContinuationSyntax)); case QueryExpressionSyntax queryExpressionSyntax: return(QueryExpression.Print(queryExpressionSyntax)); case RangeExpressionSyntax rangeExpressionSyntax: return(RangeExpression.Print(rangeExpressionSyntax)); case RecursivePatternSyntax recursivePatternSyntax: return(RecursivePattern.Print(recursivePatternSyntax)); case RefExpressionSyntax refExpressionSyntax: return(RefExpression.Print(refExpressionSyntax)); case RefTypeExpressionSyntax refTypeExpressionSyntax: return(RefTypeExpression.Print(refTypeExpressionSyntax)); case RefTypeSyntax refTypeSyntax: return(RefType.Print(refTypeSyntax)); case RefValueExpressionSyntax refValueExpressionSyntax: return(RefValueExpression.Print(refValueExpressionSyntax)); case RelationalPatternSyntax relationalPatternSyntax: return(RelationalPattern.Print(relationalPatternSyntax)); case ReturnStatementSyntax returnStatementSyntax: return(ReturnStatement.Print(returnStatementSyntax)); case SelectClauseSyntax selectClauseSyntax: return(SelectClause.Print(selectClauseSyntax)); case SimpleBaseTypeSyntax simpleBaseTypeSyntax: return(SimpleBaseType.Print(simpleBaseTypeSyntax)); case SimpleLambdaExpressionSyntax simpleLambdaExpressionSyntax: return(SimpleLambdaExpression.Print(simpleLambdaExpressionSyntax)); case SingleVariableDesignationSyntax singleVariableDesignationSyntax: return(SingleVariableDesignation.Print(singleVariableDesignationSyntax)); case SizeOfExpressionSyntax sizeOfExpressionSyntax: return(SizeOfExpression.Print(sizeOfExpressionSyntax)); case StackAllocArrayCreationExpressionSyntax stackAllocArrayCreationExpressionSyntax: return(StackAllocArrayCreationExpression.Print( stackAllocArrayCreationExpressionSyntax )); case SwitchExpressionSyntax switchExpressionSyntax: return(SwitchExpression.Print(switchExpressionSyntax)); case SwitchSectionSyntax switchSectionSyntax: return(SwitchSection.Print(switchSectionSyntax)); case SwitchStatementSyntax switchStatementSyntax: return(SwitchStatement.Print(switchStatementSyntax)); case ThisExpressionSyntax thisExpressionSyntax: return(ThisExpression.Print(thisExpressionSyntax)); case ThrowExpressionSyntax throwExpressionSyntax: return(ThrowExpression.Print(throwExpressionSyntax)); case ThrowStatementSyntax throwStatementSyntax: return(ThrowStatement.Print(throwStatementSyntax)); case TryStatementSyntax tryStatementSyntax: return(TryStatement.Print(tryStatementSyntax)); case TupleElementSyntax tupleElementSyntax: return(TupleElement.Print(tupleElementSyntax)); case TupleExpressionSyntax tupleExpressionSyntax: return(TupleExpression.Print(tupleExpressionSyntax)); case TupleTypeSyntax tupleTypeSyntax: return(TupleType.Print(tupleTypeSyntax)); case TypeArgumentListSyntax typeArgumentListSyntax: return(TypeArgumentList.Print(typeArgumentListSyntax)); case TypeConstraintSyntax typeConstraintSyntax: return(TypeConstraint.Print(typeConstraintSyntax)); case TypeOfExpressionSyntax typeOfExpressionSyntax: return(TypeOfExpression.Print(typeOfExpressionSyntax)); case TypeParameterConstraintClauseSyntax typeParameterConstraintClauseSyntax: return(TypeParameterConstraintClause.Print( typeParameterConstraintClauseSyntax )); case TypeParameterListSyntax typeParameterListSyntax: return(TypeParameterList.Print(typeParameterListSyntax)); case TypeParameterSyntax typeParameterSyntax: return(TypeParameter.Print(typeParameterSyntax)); case TypePatternSyntax typePatternSyntax: return(TypePattern.Print(typePatternSyntax)); case UnaryPatternSyntax unaryPatternSyntax: return(UnaryPattern.Print(unaryPatternSyntax)); case UnsafeStatementSyntax unsafeStatementSyntax: return(UnsafeStatement.Print(unsafeStatementSyntax)); case UsingDirectiveSyntax usingDirectiveSyntax: return(UsingDirective.Print(usingDirectiveSyntax)); case UsingStatementSyntax usingStatementSyntax: return(UsingStatement.Print(usingStatementSyntax)); case VariableDeclarationSyntax variableDeclarationSyntax: return(VariableDeclaration.Print(variableDeclarationSyntax)); case VariableDeclaratorSyntax variableDeclaratorSyntax: return(VariableDeclarator.Print(variableDeclaratorSyntax)); case VarPatternSyntax varPatternSyntax: return(VarPattern.Print(varPatternSyntax)); case WhenClauseSyntax whenClauseSyntax: return(WhenClause.Print(whenClauseSyntax)); case WhereClauseSyntax whereClauseSyntax: return(WhereClause.Print(whereClauseSyntax)); case WhileStatementSyntax whileStatementSyntax: return(WhileStatement.Print(whileStatementSyntax)); case WithExpressionSyntax withExpressionSyntax: return(WithExpression.Print(withExpressionSyntax)); case YieldStatementSyntax yieldStatementSyntax: return(YieldStatement.Print(yieldStatementSyntax)); default: throw new Exception("Can't handle " + syntaxNode.GetType().Name); } } finally { depth--; } }
private void Visit(MemberAccessExpression expression, Declaration parent, IBoundExpression withExpression) { Visit(expression.LExpression, parent, withExpression); }
public virtual void VisitMemberAccessExpression(MemberAccessExpression node) => DefaultVisit(node);
static dynamic handle(MemberAccessExpression dot) { //TODO: getters/setters/properties dynamic left = dot.Left; dynamic right = dot.Right; if (left is MemberAccessExpression) { while (left is MemberAccessExpression) { left = handle_dyn(dot.Left); //aha! } if (_member_access_ptr) { return(left.fields[right.Identifier]); } else { return(left.fields[right.Identifier].value); } } string first = left.Identifier; string second = right.Identifier; //see "handle(BinaryExpression v)" if (_member_access_ptr) { //if we have a "localvar.field" match.. [always check local var first. symbol hiding rule] if (executingFunction.Localvars.has(first)) { return(executingFunction.Localvars[first].fields[second]); } //if we have a "class.field" match.. (static field access) if (classes.has(first) && classes[first].staticfields.has(second)) { return(classes[first].staticfields[second]); } //if we have a "field.field" match.. if (executingClass.fields.has(first)) { return(executingClass.fields[first].fields[second]); } } else { //if we have a "localvar.field" match.. [always check local var first. symbol hiding rule] if (executingFunction.Localvars.has(first)) { return(executingFunction.Localvars[first].fields[second].value); } //if we have a "class.field" match.. (static field access) if (classes.has(first) && classes[first].staticfields.has(second)) { return(classes[first].staticfields[second].value); } //if we have a "field.field" match.. if (executingClass.fields.has(first)) { return(executingClass.fields[first].fields[second].value); } } throw new NotImplementedException(); }
public void evalInstruction(InstructionExpression instr) { if (instr is ValueExpression) { valueExp = (ValueExpression)instr; if (valueExp.type == ObjectType.intType) { variables.Add(valueExp.name, new ObjectExpression(valueExp.type, 0)); } else if (valueExp.type == ObjectType.booleanType) { variables.Add(valueExp.name, new ObjectExpression(valueExp.type, false)); } else if (valueExp.type == ObjectType.stringType) { variables.Add(valueExp.name, new ObjectExpression(valueExp.type, "")); } if (valueExp.value != null) { variables[valueExp.name] = new ObjectExpression(valueExp.type, evalSimpleExpression(valueExp.value).value); } return; } else if (instr is AssignExpression) { assignExp = (AssignExpression)instr; variables[assignExp.name] = evalSimpleExpression(assignExp.value); return; } else if (instr is OpenMsgDialogInstruction) { gScreen.msgBox.openBox(); return; } else if (instr is MsgDisplayInstruction) { msgExp = (MsgDisplayInstruction)instr; o1 = evalSimpleExpression(msgExp.msg); if (o1.type != ObjectType.stringType) { return; } gScreen.msgBox.setText((string)o1.value); return; } else if (instr is NextMsgDialogInstruction) { shouldEvalSeq = false; gScreen.msgBox.showNextButton(); return; } else if (instr is CloseMsgDialogInstruction) { shouldEvalSeq = false; gScreen.msgBox.showCloseButton(); return; } else if (instr is SwitchCharacterInstruction) { try { gScreen.msgBox.switchCharacter(IrisData.characters[((SwitchCharacterInstruction)instr).character.name]); } catch (Exception e) { return; } return; } else if (instr is RemoveCharacter) { gScreen.msgBox.removeCharacter(); return; } else if (instr is SetVariableInstruction) { setExp = (SetVariableInstruction)instr; /*if (!playerVariables.ContainsKey(setExp.variable.name)) * { * playerVariables.Add(setExp.variable.name, -1); * } * * playerVariables[setExp.variable.name] = (int)(evalSimpleExpression(setExp.value).value);*/ IrisData.setPlayerVariable(setExp.variable.name, (int)(evalSimpleExpression(setExp.value).value)); return; } else if (instr is InputInstruction) { inputExp = (InputInstruction)instr; o1 = variables[inputExp.name]; shouldEvalSeq = false; if (o1.type == ObjectType.intType) { gScreen.iBox.openBox(InputBox.InputType.INT_INPUT); lastInstr = inputExp; } else if (o1.type == ObjectType.stringType) { gScreen.iBox.openBox(InputBox.InputType.STRING_INPUT); lastInstr = inputExp; } return; } else if (instr is MenuInstruction) { menuExp = (MenuInstruction)instr; shouldEvalSeq = false; gScreen.menBox.setChoices(((MenuInstruction)instr).choices); gScreen.menBox.openMenu(); lastInstr = menuExp; return; } else if (instr is PlayMediaInstruction) { playExp = (PlayMediaInstruction)instr; /*if (!IrisData.sounds.ContainsKey(playExp.name)) * { * return; * }*/ //else if(IrisData. try { gScreen.playMedia(IrisData.sounds[playExp.name]); } catch (Exception e) { return; } return; } else if (instr is StopMediaInstruction) { gScreen.stopMedia(); return; } else if (instr is ShowImageInstruction) { showExp = (ShowImageInstruction)instr; if (showExp.image is VariableExpression) { img = IrisData.images[((VariableExpression)showExp.image).name]; } else { memberExp = (MemberAccessExpression)showExp.image; charac = IrisData.characters[memberExp.name]; img = charac.getImage(memberExp.field); } gScreen.showImage(img, showExp.position); return; } else if (instr is SetBackgroundInstruction) { bgdInstr = (SetBackgroundInstruction)instr; try { gScreen.setBackground(IrisData.backgrounds[bgdInstr.image.name]); } catch (Exception e) { return; } return; } else if (instr is CleanBackgroundInstruction) { gScreen.clearBackground(); return; } else if (instr is CleanForegroundInstruction) { gScreen.clearForeGround(); return; } else if (instr is GotoInstruction) { gotoExp = (GotoInstruction)instr; npcExp = gotoExp.npc; evalExpression(IrisData.npcs[npcExp.npc].labels[npcExp.label]); return; } }
public abstract string DumpMemberAccessExpression( MemberAccessExpression exp );
// ****** public abstract object EvalMemberAccessExpression( object obj, MemberAccessExpression exp );
static Expression ParseTillTerminator(ref TokenParser parser, string terminatorChars, bool throwOnTerminator, bool throwOnEnd, out char?token) { ExpressionOperatorGroup left = default; token = null; while (true) { if (parser.TryConsumeAny(terminatorChars.AsSpan(), out var consumedToken)) { if (throwOnTerminator || left.Empty) { throw new ExpressionParseException($"Unexpected '{token}'", parser.Position - 1); } token = consumedToken; return(left.ToExpression()); } parser.SkipWhitespace(); if (parser.Length == 0) { if (throwOnEnd || left.Empty) { throw new ExpressionParseException("Unexpected end of expression", parser.Position); } return(left.ToExpression()); } ExpressionType?op = null; if (left.NotEmpty) { if (parser.TryConsume('?')) { var truePart = ParseTillTerminator(ref parser, ":", false, true, out _); // pass through the current parsing rules to consume the rest var falsePart = ParseTillTerminator(ref parser, terminatorChars, throwOnTerminator, throwOnEnd, out token); return(new ConditionalExpression(left.ToExpression(), truePart, falsePart)); } // We expect a binary operator here if (!TryParseOperator(ref parser, out var sop)) { throw new ExpressionParseException("Unexpected token", parser.Position); } op = sop; } // We expect an expression to be parsed (either due to expecting a binary operator or parsing the first part var applyNegation = false; while (parser.TryConsume('!')) { applyNegation = !applyNegation; } var applyUnaryMinus = false; while (parser.TryConsume('-')) { applyUnaryMinus = !applyUnaryMinus; } Expression?parsed; if (parser.TryConsume('(')) { parsed = ParseTillTerminator(ref parser, ")", false, true, out _); } else if (parser.TryParseCall(out var functionName)) { var parameterList = new List <Expression>(); while (true) { parameterList.Add(ParseTillTerminator(ref parser, ",)", false, true, out var closingToken)); if (closingToken == ')') { break; } if (closingToken != ',') { throw new ExpressionParseException("Unexpected end of the expression", parser.Position); } } parsed = new FunctionCallExpression(functionName.ToString(), parameterList); } else if (TryParseAtomic(ref parser, out parsed)) { // do nothing } else { throw new ExpressionParseException("Unexpected token", parser.Position); } // Parse any following member accesses while (parser.TryConsume('.')) { if (!parser.TryParseIdentifier(out var memberName)) { throw new ExpressionParseException("Unexpected token", parser.Position); } parsed = new MemberAccessExpression(parsed, memberName.ToString()); } // Apply ! operator if (applyNegation) { parsed = new UnaryExpression(parsed, ExpressionType.Not); } if (applyUnaryMinus) { if (parsed is ConstantExpression constexpr) { parsed = new ConstantExpression(-constexpr.Constant); } else { parsed = new UnaryExpression(parsed, ExpressionType.UnaryMinus); } } if (left.Empty) { left.AppendFirst(parsed); } else { left.AppendWithOperator(parsed, op !.Value); } } }
private void Visit(MemberAccessExpression expression, Func <Declaration, IdentifierReference> referenceCreator) { Visit((dynamic)expression.LExpression, referenceCreator); expression.ReferencedDeclaration.AddReference(referenceCreator(expression.ReferencedDeclaration)); }
get => this.GetOptional(MemberAccessExpression, Expression.Parse);
/// <summary> /// 式中のメンバアクセス、定数等を解析する。 /// </summary> /// <param name="syntax"></param> /// <param name="semanticModel"></param> /// <returns></returns> Expression ParseExpression(ExpressionSyntax syntax, SemanticModel semanticModel) { if (syntax == null) { return(null); } var mae = syntax as MemberAccessExpressionSyntax; var gns = syntax as GenericNameSyntax; var le = syntax as LiteralExpressionSyntax; var ie = syntax as InvocationExpressionSyntax; var oce = syntax as ObjectCreationExpressionSyntax; var ce = syntax as CastExpressionSyntax; var thise = syntax as ThisExpressionSyntax; var ae = syntax as AssignmentExpressionSyntax; var pe = syntax as ParenthesizedExpressionSyntax; var ine = syntax as IdentifierNameSyntax; var eae = syntax as ElementAccessExpressionSyntax; var be = syntax as BinaryExpressionSyntax; var preue = syntax as PrefixUnaryExpressionSyntax; var poue = syntax as PostfixUnaryExpressionSyntax; var basee = syntax as BaseExpressionSyntax; var ace = syntax as ArrayCreationExpressionSyntax; var sace = syntax as StackAllocArrayCreationExpressionSyntax; var iee = syntax as InitializerExpressionSyntax; /* * var coe = syntax as ConditionalExpressionSyntax; * var sle = syntax as SimpleLambdaExpressionSyntax; * var ple = syntax as ParenthesizedLambdaExpressionSyntax; * var oase = syntax as OmittedArraySizeExpressionSyntax; * var iace = syntax as ImplicitArrayCreationExpressionSyntax; * * var qua = syntax as QualifiedNameSyntax; * var predf = syntax as PredefinedTypeSyntax; */ // 自己の型を解析 TypeInfo?selfTypeInfo = null; selfTypeInfo = semanticModel.GetTypeInfo(syntax); var selfType = ParseType(syntax, selfTypeInfo, semanticModel); if (mae != null) { MemberAccessExpression exp = new MemberAccessExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Name = mae.Name.ToString(); if (mae.Name is GenericNameSyntax) { var gns_ = mae.Name as GenericNameSyntax; exp.Types = gns_.TypeArgumentList.Arguments.Select(_ => ParseType(_, semanticModel)).ToArray(); } TypeInfo?parentType = null; if (mae.Expression != null) { parentType = semanticModel.GetTypeInfo(mae.Expression); } // 種類を取得 var symbol = semanticModel.GetSymbolInfo(mae); var methodSymbol = symbol.Symbol as IMethodSymbol; var propertySymbol = symbol.Symbol as IPropertySymbol; // 親の種類を探索 List <ClassDef> classDefPs = new List <ClassDef>(); EnumDef enumDefP = null; InterfaceDef interfaceDefP = null; StructDef structDefP = null; // プロパティである if (propertySymbol != null) { exp.IsProperty = true; } if (parentType.HasValue && parentType.Value.Type != null) { if (parentType.Value.Type.TypeKind == TypeKind.Interface) { var memName = mae.Name.ToString(); var sym = semanticModel.GetSymbolInfo(mae); var name_ = parentType.Value.Type.Name; var namespace_ = Utils.ToStr(parentType.Value.Type.ContainingNamespace); interfaceDefP = definitions.Interfaces.Where(_ => _.Namespace == namespace_ && _.Name == name_).FirstOrDefault(); } else if (parentType.Value.Type.TypeKind == TypeKind.Class) { var memName = mae.Name.ToString(); var sym = semanticModel.GetSymbolInfo(mae); var name_ = parentType.Value.Type.Name; var namespace_ = Utils.ToStr(parentType.Value.Type.ContainingNamespace); classDefPs = definitions.FindTypeWithBases(namespace_, name_).OfType <ClassDef>().ToList(); } else if (parentType.Value.Type.TypeKind == TypeKind.Enum) { var enumName = selfTypeInfo.Value.Type.Name; var namespace_ = Utils.ToStr(selfTypeInfo.Value.Type.ContainingNamespace); enumDefP = definitions.Enums.Where(_ => _.Namespace == namespace_ && _.Name == enumName).FirstOrDefault(); } else if (parentType.Value.Type.TypeKind == TypeKind.Struct) { var memName = mae.Name.ToString(); var sym = semanticModel.GetSymbolInfo(mae); var name_ = parentType.Value.Type.Name; var namespace_ = Utils.ToStr(parentType.Value.Type.ContainingNamespace); structDefP = definitions.Structs.Where(_ => _.Namespace == namespace_ && _.Name == name_).FirstOrDefault(); } } // 親から子を探索 if (interfaceDefP != null) { if (methodSymbol != null) { var method = interfaceDefP.Methods.Where(_ => { if (_.Name != methodSymbol.Name) { return(false); } if (_.Parameters.Count() != methodSymbol.Parameters.Count()) { return(false); } for (int i = 0; i < _.Parameters.Count(); i++) { if (_.Parameters[i].Name != methodSymbol.Parameters[i].Name) { return(false); } // TODO 正しい変換 //if(_.Parameters[i].Type != methodSymbol.Parameters[i].Type) } return(true); }).FirstOrDefault(); if (method != null) { exp.Name = null; exp.Method = method; } } else if (propertySymbol != null) { var prop = interfaceDefP.Properties.Where(_ => { if (_.Name != propertySymbol.Name) { return(false); } return(true); }).FirstOrDefault(); if (prop != null) { exp.Name = null; exp.Property = prop; } } } else if (classDefPs.Count > 0) { if (methodSymbol != null) { foreach (var classDefP in classDefPs) { var method = classDefP.Methods.Where(_ => { if (_.Name != methodSymbol.Name) { return(false); } if (_.Parameters.Count() != methodSymbol.Parameters.Count()) { return(false); } for (int i = 0; i < _.Parameters.Count(); i++) { if (_.Parameters[i].Name != methodSymbol.Parameters[i].Name) { return(false); } // TODO 正しい変換 //if(_.Parameters[i].Type != methodSymbol.Parameters[i].Type) } return(true); }).FirstOrDefault(); if (method != null) { exp.Name = null; exp.Class = classDefP; exp.Method = method; // staticの場合走査停止 if (method.IsStatic) { return(exp); } break; } } } else if (propertySymbol != null) { foreach (var classDefP in classDefPs) { var prop = classDefP.Properties.Where(_ => { if (_.Name != propertySymbol.Name) { return(false); } return(true); }).FirstOrDefault(); if (prop != null) { exp.Name = null; exp.Class = classDefP; exp.Property = prop; break; } } } } else if (structDefP != null) { if (propertySymbol != null) { var prop = structDefP.Properties.Where(_ => { if (_.Name != propertySymbol.Name) { return(false); } return(true); }).FirstOrDefault(); if (prop != null) { exp.Name = null; exp.Struct = structDefP; exp.Property = prop; } } } else if (enumDefP != null) { var name = mae.Name.ToString(); exp.EnumMember = enumDefP.Members.Where(_ => _.Name == name).FirstOrDefault(); if (exp.EnumMember != null) { exp.Enum = enumDefP; exp.Name = null; } } else { // 代替処理 if (propertySymbol != null) { exp.Property = new PropertyDef(); exp.Property.Name = exp.Name; } } if (exp.EnumMember != null) { // enumのメンバーだった場合、親は必ずenumなのでこれ以上走査しない } else if (mae.Expression != null) { exp.Expression = ParseExpression(mae.Expression, semanticModel); } return(exp); } else if (gns != null) { var symbol = semanticModel.GetSymbolInfo(gns); var methodSymbol = symbol.Symbol as IMethodSymbol; var fieldSymbol = symbol.Symbol as IFieldSymbol; var propertySymbol = symbol.Symbol as IPropertySymbol; var exp = new GenericNameExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Name = gns.Identifier.ValueText; if (methodSymbol != null) { exp.IsMethod = true; } if (propertySymbol != null) { exp.IsProperty = true; } exp.Types = gns.TypeArgumentList.Arguments.Select(_ => ParseType(_, semanticModel)).ToArray(); return(exp); } else if (le != null) { var text = le.GetText().ToString(); var exp = new LiteralExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Text = text; return(exp); } else if (ie != null) { var exp = new InvocationExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Method = ParseExpression(ie.Expression, semanticModel); exp.Args = ie.ArgumentList.Arguments.Select(_ => ParseExpression(_.Expression, semanticModel)).ToArray(); return(exp); } else if (oce != null) { var exp = new ObjectCreationExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Type = ParseType(oce.Type, semanticModel); if (oce.ArgumentList != null) { exp.Args = oce.ArgumentList.Arguments.Select(_ => ParseExpression(_.Expression, semanticModel)).ToArray(); } else { exp.Args = new Expression[0]; } return(exp); } else if (ce != null) { var exp = new CastExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Type = ParseType(ce.Type, semanticModel); exp.Expression = ParseExpression(ce.Expression, semanticModel); return(exp); } else if (thise != null) { var exp = new ThisExpression(); exp.SelfType = selfType; exp.Internal = syntax; return(exp); } else if (ae != null) { var exp = new AssignmentExpression(); exp.SelfType = selfType; exp.Internal = syntax; if (ae.Kind() == SyntaxKind.AddAssignmentExpression) { exp.Type = AssignmentExpression.OperatorType.Add; } if (ae.Kind() == SyntaxKind.SubtractAssignmentExpression) { exp.Type = AssignmentExpression.OperatorType.Substract; } if (ae.Kind() == SyntaxKind.SimpleAssignmentExpression) { exp.Type = AssignmentExpression.OperatorType.Simple; } if (ae.Kind() == SyntaxKind.DivideAssignmentExpression) { exp.Type = AssignmentExpression.OperatorType.Divide; } if (ae.Kind() == SyntaxKind.ModuloAssignmentExpression) { exp.Type = AssignmentExpression.OperatorType.Modulo; } exp.Temp = ae.Kind(); exp.Target = ParseExpression(ae.Left, semanticModel); exp.Expression = ParseExpression(ae.Right, semanticModel); return(exp); } else if (pe != null) { // ()の構文 return(ParseExpression(pe.Expression, semanticModel)); } else if (ine != null) { var symbol = semanticModel.GetSymbolInfo(ine); var methodSymbol = symbol.Symbol as IMethodSymbol; var fieldSymbol = symbol.Symbol as IFieldSymbol; var propertySymbol = symbol.Symbol as IPropertySymbol; var exp = new IdentifierNameExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Name = ine.Identifier.Text; if (selfTypeInfo?.Type != null) { exp.Type = ParseType(selfTypeInfo.Value.Type); } if (methodSymbol != null) { exp.IsMethod = true; } if (propertySymbol != null) { exp.IsProperty = true; } return(exp); } else if (eae != null) { if (eae.ArgumentList.Arguments.Count() != 1) { throw new ParseException("多次元配列は使用禁止です。"); } var value_ = eae.Expression; var arg = eae.ArgumentList.Arguments[0].Expression; var exp = new ElementAccessExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Value = ParseExpression(value_, semanticModel); exp.Arg = ParseExpression(arg, semanticModel); return(exp); } else if (be != null) { var exp = new BinaryExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Left = ParseExpression(be.Left, semanticModel); exp.Right = ParseExpression(be.Right, semanticModel); if (be.Kind() == SyntaxKind.AddExpression) { exp.Operator = BinaryExpression.OperatorType.Add; } if (be.Kind() == SyntaxKind.SubtractExpression) { exp.Operator = BinaryExpression.OperatorType.Subtract; } if (be.Kind() == SyntaxKind.IsExpression) { exp.Operator = BinaryExpression.OperatorType.Is; } if (be.Kind() == SyntaxKind.AsExpression) { exp.Operator = BinaryExpression.OperatorType.As; } if (be.Kind() == SyntaxKind.EqualsExpression) { exp.Operator = BinaryExpression.OperatorType.Equals; } if (be.Kind() == SyntaxKind.NotEqualsExpression) { exp.Operator = BinaryExpression.OperatorType.NotEquals; } if (be.Kind() == SyntaxKind.LogicalAndExpression) { exp.Operator = BinaryExpression.OperatorType.LogicalAnd; } if (be.Kind() == SyntaxKind.LogicalOrExpression) { exp.Operator = BinaryExpression.OperatorType.LogicalOr; } if (be.Kind() == SyntaxKind.GreaterThanExpression) { exp.Operator = BinaryExpression.OperatorType.GreaterThan; } if (be.Kind() == SyntaxKind.GreaterThanOrEqualExpression) { exp.Operator = BinaryExpression.OperatorType.GreaterThanOrEqual; } if (be.Kind() == SyntaxKind.LessThanExpression) { exp.Operator = BinaryExpression.OperatorType.LessThan; } if (be.Kind() == SyntaxKind.LessThanOrEqualExpression) { exp.Operator = BinaryExpression.OperatorType.LessThanOrEqual; } if (be.Kind() == SyntaxKind.MultiplyExpression) { exp.Operator = BinaryExpression.OperatorType.Multiply; } if (be.Kind() == SyntaxKind.DivideExpression) { exp.Operator = BinaryExpression.OperatorType.Divide; } if (be.Kind() == SyntaxKind.ModuloExpression) { exp.Operator = BinaryExpression.OperatorType.Modulo; } if (exp.Operator == BinaryExpression.OperatorType.None) { var span_ = syntax.SyntaxTree.GetLineSpan(syntax.Span); Console.WriteLine(string.Format("{0} : {1} には未対応です。", span_, be.Kind())); } return(exp); } else if (preue != null) { var exp = new PrefixUnaryExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Expression = ParseExpression(preue.Operand, semanticModel); switch (preue.Kind()) { case SyntaxKind.LogicalNotExpression: exp.Type = PrefixUnaryExpression.OperatorType.LogicalNot; break; case SyntaxKind.UnaryPlusExpression: exp.Type = PrefixUnaryExpression.OperatorType.UnaryPlus; break; case SyntaxKind.UnaryMinusExpression: exp.Type = PrefixUnaryExpression.OperatorType.UnaryMinus; break; case SyntaxKind.PreIncrementExpression: exp.Type = PrefixUnaryExpression.OperatorType.PreIncrement; break; default: throw new Exception(); break; } return(exp); } else if (poue != null) { var exp = new PostfixUnaryExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Operand = ParseExpression(poue.Operand, semanticModel); if (poue.Kind() == SyntaxKind.PostIncrementExpression) { exp.Type = PostfixUnaryExpression.OperatorType.PostIncrement; } if (poue.Kind() == SyntaxKind.PostDecrementExpression) { exp.Type = PostfixUnaryExpression.OperatorType.PostDecrement; } return(exp); } else if (basee != null) { var exp = new BaseExpression(); exp.SelfType = selfType; exp.Internal = syntax; return(exp); } else if (iee != null) { var exp = new InitializerExpression(); exp.SelfType = selfType; exp.Internal = syntax; var expressions = iee.Expressions.Select(_ => _).ToArray(); exp.Expressions = expressions.Select(_ => ParseExpression(_, semanticModel)).ToArray(); return(exp); } else if (ace != null || sace != null) { // stackallocも含め、配列の確保として扱う。 ArrayTypeSyntax ats = null; if (ace != null) { ats = ace.Type; } if (sace != null) { ats = sace.Type as ArrayTypeSyntax; } var exp = new ObjectArrayCreationExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Type = ParseType(ats.ElementType, semanticModel); exp.Args = ats.RankSpecifiers.Select(_ => ParseExpression(_.Sizes.FirstOrDefault(), semanticModel)).ToArray(); return(exp); } else if (syntax is PredefinedTypeSyntax) { var s = syntax as PredefinedTypeSyntax; var exp = new TypeExpression(); exp.SelfType = selfType; exp.Internal = syntax; return(exp); } else if (syntax is QualifiedNameSyntax) { var s = syntax as QualifiedNameSyntax; var exp = new TypeExpression(); exp.SelfType = selfType; exp.Internal = syntax; return(exp); } var span = syntax.SyntaxTree.GetLineSpan(syntax.Span); Console.WriteLine(string.Format("{0} : {1} には未対応です。", span, syntax.GetType())); return(null); }
public virtual void Visit(MemberAccessExpression memberAccessExpression) { Visit(memberAccessExpression.Operand); Visit(memberAccessExpression.Member); }
public override void Visit(MemberAccessExpression memberAccessExpression) { Visit(memberAccessExpression.Operand); Write("."); Visit(memberAccessExpression.Member); }
/////////////////////////////////////////////////////////////////////////////// // //public override string DumpMacroExpression( MacroExpression exp ) //{ // return exp.MacroName; //} // ///////////////////////////////////////////////////////////////////////////// public override string DumpMemberAccessExpression( MemberAccessExpression exp ) { return string.Format( ".{0}", exp.MemberName ); }
protected virtual void VisitMemberAccessExpression(MemberAccessExpression memberAccessExpression) { Visit(memberAccessExpression.Target); Visit(memberAccessExpression.Member); }