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