/// <summary> /// Generates the code for an <see cref="PropertyReferenceExpression"/>. /// </summary> /// <param name="expression">The expression</param> /// <returns>A BaZic code</returns> private string GeneratePropertyReferenceExpression(PropertyReferenceExpression expression) { Requires.NotNull(expression.TargetObject, nameof(expression.TargetObject)); var targetObject = GenerateReferenceExpression(expression.TargetObject); return($"{targetObject}.{expression.PropertyName}"); }
public override void VisitPropertyReferenceExpression(PropertyReferenceExpression node) { if (IsGetCurrent(node)) { ResultingType = node.ExpressionType; } base.VisitPropertyReferenceExpression(node); }
public override void VisitPropertyReferenceExpression(PropertyReferenceExpression node) { base.VisitPropertyReferenceExpression(node); if (node.IsIndexer) { CheckArguments(node.Property.Parameters, node.Arguments); } }
public override ICodeNode VisitPropertyReferenceExpression(PropertyReferenceExpression node) { V_0 = (PropertyReferenceExpression)this.VisitPropertyReferenceExpression(node); if (node.get_Arguments().get_Count() > 0) { this.VisitInvocationArguments(V_0.get_Arguments(), V_0.get_MethodExpression().get_Method()); } return(V_0); }
public override void VisitPropertyReferenceExpression(PropertyReferenceExpression node) { if (this.IsGetCurrent(node)) { this.set_ResultingType(node.get_ExpressionType()); } this.VisitPropertyReferenceExpression(node); return; }
public void PropertyReferenceExpressionTests() { var reference = new PropertyReferenceExpression(); Assert.IsNull(reference.PropertyName); reference = new PropertyReferenceExpression(new VariableReferenceExpression("Foo"), "Boo"); Assert.AreEqual("Foo.Boo", reference.ToString()); }
public override void VisitPropertyReferenceExpression(PropertyReferenceExpression node) { if (state == SearchState.Propagation) { canBePropagated = false; return; } base.VisitPropertyReferenceExpression(node); }
public override void VisitPropertyReferenceExpression(PropertyReferenceExpression node) { this.VisitPropertyReferenceExpression(node); if (node.get_IsIndexer()) { this.CheckArguments(node.get_Property().get_Parameters(), node.get_Arguments()); } return; }
public override ICodeNode VisitPropertyReferenceExpression(PropertyReferenceExpression node) { dummyVar0 = this.VisitPropertyReferenceExpression(node); if (node.get_Target() == null || node.get_Target().get_CodeNodeType() != 26 || !this.get_TransparentIdentifierToPropertyValueMap().TryGetValue((node.get_Target() as VariableReferenceExpression).get_Variable(), out V_0)) { return(node); } return(new VariableReferenceExpression(V_0.get_Item(node.get_MethodExpression().get_MethodDefinition()), node.get_UnderlyingSameMethodInstructions())); }
public override ICodeNode VisitPropertyReferenceExpression(PropertyReferenceExpression node) { PropertyReferenceExpression result = (PropertyReferenceExpression)base.VisitPropertyReferenceExpression(node); if (node.Arguments.Count > 0) { VisitInvocationArguments(result.Arguments, result.MethodExpression.Method); } return(result); }
public override void VisitPropertyReferenceExpression(PropertyReferenceExpression node) { if (this.state == ExpressionPropagationStep.ExpressionTreeVisitor.SearchState.Propagation) { this.canBePropagated = false; return; } this.VisitPropertyReferenceExpression(node); return; }
private ICodeNode ConvertProperty(MethodInvocationExpression invocation) { MethodInvocationExpression methodInvocation = ConvertCall(invocation) as MethodInvocationExpression; if (methodInvocation != null) { PropertyReferenceExpression result = new PropertyReferenceExpression(methodInvocation, null); return(result.Property != null ? result : null); } return(null); }
public override ICodeNode VisitPropertyReferenceExpression(PropertyReferenceExpression node) { if (node.Property.Name == "Current") { VariableReferenceExpression nodeTarget = node.Target as VariableReferenceExpression; if (nodeTarget != null && nodeTarget.Variable == enumerator) { return(new VariableReferenceExpression(foreachVariable, null)); } } return(base.VisitPropertyReferenceExpression(node)); }
public override ICodeNode VisitPropertyReferenceExpression(PropertyReferenceExpression node) { if (String.op_Equality(node.get_Property().get_Name(), "Current")) { V_0 = node.get_Target() as VariableReferenceExpression; if (V_0 != null && (object)V_0.get_Variable() == (object)this.enumerator) { return(new VariableReferenceExpression(this.foreachVariable, null)); } } return(this.VisitPropertyReferenceExpression(node)); }
public override ICodeNode VisitMethodInvocationExpression(MethodInvocationExpression node) { ICodeNode newNode = typeOfStep.VisitMethodInvocationExpression(node); if (newNode != null) { return(newNode); } replaceThisWithBaseStep.VisitMethodInvocationExpression(node); newNode = operatorStep.VisitMethodInvocationExpression(node); if (newNode != null) { return(base.Visit(newNode)); } newNode = replaceDelegateInvokeStep.VisitMethodInvocationExpression(node); if (newNode != null) { return(base.VisitDelegateInvokeExpression(newNode as DelegateInvokeExpression)); } newNode = propertyStep.VisitMethodInvocationExpression(node); if (newNode != null) { PropertyReferenceExpression propertyReference = newNode as PropertyReferenceExpression; if (propertyReference != null) // if it was a getter { newNode = this.VisitPropertyReferenceExpression(propertyReference); } if (newNode is BinaryExpression) // if it was a setter { newNode = this.VisitBinaryExpression(newNode as BinaryExpression); } return(newNode); } newNode = rebuildEventsStep.VisitMethodInvocationExpression(node); if (newNode != null) { if (newNode is BinaryExpression) { return(VisitBinaryExpression(newNode as BinaryExpression)); } return(newNode); } return(base.VisitMethodInvocationExpression(node)); }
public override void VisitPropertyReferenceExpression(PropertyReferenceExpression node) { if (String.op_Inequality(node.get_Property().get_Name(), "Current")) { V_0 = node.get_Target() as VariableReferenceExpression; if (V_0 != null && (object)V_0.get_Variable() == (object)this.enumerator) { this.set_IsEnumeratorUsed(true); } } this.VisitPropertyReferenceExpression(node); return; }
public override void VisitPropertyReferenceExpression(PropertyReferenceExpression node) { if (node.Property.Name != "Current") { VariableReferenceExpression nodeTarget = node.Target as VariableReferenceExpression; if (nodeTarget != null && nodeTarget.Variable == enumerator) { IsEnumeratorUsed = true; } } base.VisitPropertyReferenceExpression(node); }
public override ICodeNode VisitPropertyReferenceExpression(PropertyReferenceExpression node) { base.VisitPropertyReferenceExpression(node); Dictionary <MethodDefinition, VariableReference> methodDefToIdentifierReference; if (node.Target != null && node.Target.CodeNodeType == CodeNodeType.VariableReferenceExpression && this.TransparentIdentifierToPropertyValueMap.TryGetValue((node.Target as VariableReferenceExpression).Variable, out methodDefToIdentifierReference)) { return(new VariableReferenceExpression(methodDefToIdentifierReference[node.MethodExpression.MethodDefinition], node.UnderlyingSameMethodInstructions)); } return(node); }
public override void VisitPropertyReferenceExpression(PropertyReferenceExpression node) { if (node.Target != null) { Visit(node.Target); } else { WriteReference(node.Property.DeclaringType); } WriteToken("."); Write(node.Property.Name); }
public override ICodeNode VisitPropertyReferenceExpression(PropertyReferenceExpression node) { V_0 = node.get_MethodExpression(); if (V_0.get_Target() == null || V_0.get_Target().get_CodeNodeType() != 26 || !this.asyncData.get_AwaiterVariables().Contains((V_0.get_Target() as VariableReferenceExpression).get_Variable())) { return(this.VisitPropertyReferenceExpression(node)); } V_1 = (V_0.get_Target() as VariableReferenceExpression).get_Variable(); if ((object)this.currentAwaiterVariable == (object)V_1 && String.op_Equality(V_0.get_Method().get_Name(), "get_IsCompleted") && this.matcherState == 1) { this.matcherState = 6; return(null); } this.matcherState = 8; return(node); }
public override void VisitPropertyReferenceExpression(PropertyReferenceExpression node) { if (!foundWhile && IsGetCurrent(node)) { //TryStatement ts = theTry; ClearState(); //theTry = ts; //insideTry = ts != null; } else { if (IsGetCurrent(node)) { foreachVariableType = node.ExpressionType; } } }
public ICodeNode VisitMethodInvocationExpression(MethodInvocationExpression node) { MethodReferenceExpression methodRef = node.MethodExpression; if (methodRef == null) { return(null); } MethodDefinition method = methodRef.Method as MethodDefinition; //// must be resolved. if (method == null) { MethodReference methodReference = methodRef.Method; if (methodReference != null && !string.IsNullOrEmpty(methodReference.Name) && (methodReference.Name.StartsWith("set_") || methodReference.Name.StartsWith("get_") || methodReference.Name.StartsWith("put_") /*Setter prefix in winrt*/)) { method = methodReference.Resolve(); } } if (method != null) { if (method.IsGetter || method.IsSetter) { PropertyReferenceExpression propExpr = new PropertyReferenceExpression(node, null); if (propExpr.Property == null) { // sanity check - if the method is resolved and is determined to be getter/setter, then a // property record should be available. return(node); } Expression result = propExpr; if (method.IsSetter) { int last = node.Arguments.Count - 1; result = new BinaryExpression(BinaryOperator.Assign, propExpr, node.Arguments[last], typeSystem, null); } return(result); } } return(null); }
private bool IsGetCurrent(Expression expression) { MethodInvocationExpression methodInvocation = expression as MethodInvocationExpression; if (methodInvocation == null) { PropertyReferenceExpression propertyExpression = expression as PropertyReferenceExpression; return(propertyExpression != null && propertyExpression.Property.Name == "Current"); } if (methodInvocation.MethodExpression.Target as VariableReferenceExpression == null || methodInvocation.MethodExpression.Method.Name != "get_Current") { return(false); } if ((methodInvocation.MethodExpression.Target as VariableReferenceExpression).Variable != theEnumerator) { return(false); } return(true); }
private Expression GetMethodHandleExpression(MethodReference methodReference, IEnumerable <Instruction> instructions) { TypeDefinition corlibTypeTypeDefinition = GetSystemTypeTypeDefinition(); string[] parametersNames = methodReference.HasParameters ? new string[] { "System.String", "System.Type[]" } : new string[] { "System.String" }; MethodReference getMethodReference = GetSystemTypeMethodReference(corlibTypeTypeDefinition, "GetMethod", parametersNames); MethodReference getMethodHandleReference = GetHandlePropertyGetterReference(typeof(System.Reflection.MethodBase), "get_MethodHandle"); TypeOfExpression typeOfExpression = new TypeOfExpression(methodReference.DeclaringType, null); MethodReferenceExpression getMethodMethodReferenceExpression = new MethodReferenceExpression(typeOfExpression, getMethodReference, null); MethodInvocationExpression getMethodMethodInvocationExpression = new MethodInvocationExpression(getMethodMethodReferenceExpression, null); LiteralExpression argument = new LiteralExpression(methodReference.Name, this.typeSystem, null); getMethodMethodInvocationExpression.Arguments.Add(argument); if (methodReference.HasParameters) { BlockExpression blockExpression = new BlockExpression(null); foreach (ParameterDefinition parameter in methodReference.Parameters) { blockExpression.Expressions.Add(new TypeOfExpression(parameter.ParameterType, null)); } InitializerExpression initializer = new InitializerExpression(blockExpression, InitializerType.ArrayInitializer); ArrayCreationExpression getMethodTypeParametersArray = new ArrayCreationExpression(corlibTypeTypeDefinition, initializer, null); getMethodTypeParametersArray.Dimensions.Add(new LiteralExpression(blockExpression.Expressions.Count, this.typeSystem, null)); getMethodMethodInvocationExpression.Arguments.Add(getMethodTypeParametersArray); } MethodReferenceExpression getMethodHandleMethodReferenceExpression = new MethodReferenceExpression(getMethodMethodInvocationExpression, getMethodHandleReference, null); MethodInvocationExpression getMethodHandleMethodInvocationExpression = new MethodInvocationExpression(getMethodHandleMethodReferenceExpression, instructions); PropertyReferenceExpression methodHandlePropertyReferenceExpression = new PropertyReferenceExpression(getMethodHandleMethodInvocationExpression, null); return(methodHandlePropertyReferenceExpression); }
public virtual void VisitPropertyReferenceExpression(PropertyReferenceExpression node) { this.Visit(node.get_Target()); this.Visit(node.get_Arguments()); return; }
public virtual ICodeNode VisitPropertyReferenceExpression(PropertyReferenceExpression node) { node.Target = (Expression)Visit(node.Target); node.Arguments = (ExpressionCollection)Visit(node.Arguments); return(node); }
public static CodeCompileUnit TestStatementsAndExpressionsCompileUnit() { CodeCompileUnit compileUnit = new CodeCompileUnit(); CodeNamespace codeNamespace = new CodeNamespace("Test.Namespace"); CodeTypeDeclaration classDeclaration = new CodeTypeDeclaration("TestClass") { IsClass = true }; classDeclaration.TypeAttributes = (classDeclaration.TypeAttributes & ~TypeAttributes.VisibilityMask) | TypeAttributes.Public; var method = new CodeMemberMethod() { Name = "Method", Attributes = MemberAttributes.Public | MemberAttributes.Final }; CodeFieldReferenceExpression fieldRef = FieldReferenceExpression.This("field"); CodeArgumentReferenceExpression argRef = new CodeArgumentReferenceExpression("arg"); CodeVariableReferenceExpression varRef = new CodeVariableReferenceExpression("avar"); method.Statements.Add(new CodeArrayCreateExpression(new CodeTypeReference("Class"), new CodeObjectCreateExpression(new CodeTypeReference("A")), new CodeObjectCreateExpression(new CodeTypeReference("A"), fieldRef, argRef))); method.Statements.Add(new CodeArrayCreateExpression(Types.Double, new CodeBinaryOperatorExpression(argRef, CodeBinaryOperatorType.Multiply, varRef))); method.Statements.Add(new CodeArrayIndexerExpression(varRef, new CodeCastExpression(typeof(int), Primitives.Float(5.5f)), new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("Math"), "Abs", Primitives.Int(-2)))); method.Statements.Add(new CodeDefaultValueExpression(Types.UInt)); method.Statements.Add(new CodeTypeOfExpression(Types.Int)); method.Statements.Add(new CodeIterationStatement( new CodeVariableDeclarationStatement( Types.Int, "i", Primitives.Int(0)), new CodeBinaryOperatorExpression( new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.LessThan, Primitives.Int(10)), new CodeAssignStatement( new CodeVariableReferenceExpression("i"), new CodeBinaryOperatorExpression( new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.Add, Primitives.Int(1))), new CodeTryCatchFinallyStatement( new CodeStatement[] { new CodeAttachEventStatement( new CodeEventReferenceExpression(PropertyReferenceExpression.Base("EventsHolder"), "AnEvent"), DelegateCreateExpression.This(new CodeTypeReference("Action"), "Method") ) }, new CodeCatchClause[] { new CodeCatchClause("e", new CodeTypeReference("Exception")), new CodeCatchClause("e", new CodeTypeReference("AnotherException")) }))); classDeclaration.Members.Add(method); codeNamespace.Types.Add(classDeclaration); compileUnit.Namespaces.Add(codeNamespace); return(compileUnit); }
public virtual void VisitPropertyReferenceExpression(PropertyReferenceExpression node) { Visit(node.Target); Visit(node.Arguments); }
/// <summary> /// Parse a part of an expression that can be a reference or primary value followed by an accesser like array indexer or method invocation. /// /// Corresponding grammar : /// Primary_Expression_Start Bracket_Expression* ((Member_Access | Method_Invocation) Bracket_Expression* )* /// </summary> /// <param name="isRequired">Defines whether it is required/expected to parse an expression. If true, throw an exception if no expression is parsed.</param> /// <returns>Returns an expression.</returns> private Expression ParsePrimaryExpression(bool isRequired) { Expression[] bracketExpression = null; var expressionLine = CurrentToken.Line; var expressionColumn = CurrentToken.Column; var expressionStartOffset = CurrentToken.StartOffset; var expressionParsedLength = CurrentToken.ParsedLength; // Primary_Expression_Start var expression = ParsePrimaryExpressionStart(isRequired); // Bracket_Expression * do { var bracketToken = CurrentToken; bracketExpression = ParseBracketExpression(); if (bracketExpression != null) { var referenceExpression = expression as ReferenceExpression; if (referenceExpression == null) { AddIssue(new BaZicParserException(expressionLine, expressionColumn, expressionStartOffset, expressionParsedLength, L.BaZic.Parser.Expressions.UnexpectedIndexer)); } if (bracketExpression.Length == 0) { AddIssue(new BaZicParserException(bracketToken.Line, bracketToken.Column, expressionStartOffset, expressionParsedLength, L.BaZic.Parser.Expressions.IndexerExpected)); return(null); } var arrayIndexer = new ArrayIndexerExpression(referenceExpression, bracketExpression) { Line = bracketToken.Line, Column = bracketToken.Column, StartOffset = bracketToken.StartOffset, NodeLength = bracketToken.ParsedLength }; ValidateArrayIndexerExpression(arrayIndexer); expression = arrayIndexer; } } while (bracketExpression != null); // ((Member_Access | Method_Invocation) Bracket_Expression* )* while (CurrentToken.TokenType == TokenType.Dot || CurrentToken.TokenType == TokenType.LeftParenth) { if (CurrentToken.TokenType == TokenType.Dot) { // Member_Access var memberNameToken = CurrentToken; var memberAccess = ParseMemberAccessPart(true); if (!string.IsNullOrEmpty(memberAccess)) { var referenceExpression = expression as ReferenceExpression; if (referenceExpression == null) { AddIssue(new BaZicParserException(expressionLine, expressionColumn, expressionStartOffset, expressionParsedLength, L.BaZic.Parser.Expressions.IllegalPropertyAccess)); } expression = new PropertyReferenceExpression(referenceExpression, memberAccess) { Line = memberNameToken.Line, Column = memberNameToken.Column + 1, // +1 because we don't want to show a potential error on the dot. StartOffset = memberNameToken.StartOffset + 1, // +1 because we don't want to show a potential error on the dot. NodeLength = memberNameToken.ParsedLength }; } } else if (CurrentToken.TokenType == TokenType.LeftParenth) { // Method_Invocation var methodInvocationParameters = ParseMethodInvocation(); var propertyReferenceExpression = expression as PropertyReferenceExpression; if (expression is VariableReferenceExpression variableReferenceExpression) { var methodInvoke = new InvokeMethodExpression(variableReferenceExpression.Name.ToString(), false) { Line = variableReferenceExpression.Line, Column = variableReferenceExpression.Column, StartOffset = variableReferenceExpression.StartOffset, NodeLength = variableReferenceExpression.NodeLength } .WithParameters(methodInvocationParameters); AddMethodInvocation(methodInvoke); expression = methodInvoke; } else if (propertyReferenceExpression != null) { var methodInvoke = new InvokeCoreMethodExpression(propertyReferenceExpression.TargetObject, propertyReferenceExpression.PropertyName.ToString(), false) { Line = propertyReferenceExpression.Line, Column = propertyReferenceExpression.Column, StartOffset = propertyReferenceExpression.StartOffset, NodeLength = propertyReferenceExpression.NodeLength }; methodInvoke.WithParameters(methodInvocationParameters); ValidateCoreMethodInvocation(methodInvoke); expression = methodInvoke; } else { AddIssue(new BaZicParserException(expressionLine, expressionColumn, expressionStartOffset, expressionParsedLength, L.BaZic.Parser.Expressions.MethodNameExpected)); } } else { AddIssue(new BaZicParserException(expressionLine, expressionColumn, expressionStartOffset, expressionParsedLength, L.BaZic.Parser.Expressions.MethodNameExpected)); } // Bracket_Expression* do { var bracketToken = CurrentToken; bracketExpression = ParseBracketExpression(); if (bracketExpression != null) { var referenceExpression = expression as ReferenceExpression; if (referenceExpression == null) { AddIssue(new BaZicParserException(expressionLine, expressionColumn, expressionStartOffset, expressionParsedLength, L.BaZic.Parser.Expressions.UnexpectedIndexer)); } if (bracketExpression.Length == 0) { AddIssue(new BaZicParserException(bracketToken.Line, bracketToken.Column, expressionStartOffset, expressionParsedLength, L.BaZic.Parser.Expressions.IndexerExpected)); } var arrayIndexer = new ArrayIndexerExpression(referenceExpression, bracketExpression) { Line = bracketToken.Line, Column = bracketToken.Column, StartOffset = bracketToken.StartOffset, NodeLength = bracketToken.ParsedLength }; ValidateArrayIndexerExpression(arrayIndexer); expression = arrayIndexer; } } while (bracketExpression != null); } return(expression); }
public override void VisitPropertyReferenceExpression(PropertyReferenceExpression node) { TrySetPendingName(node.Property.Name, true); base.VisitPropertyReferenceExpression(node); }