/// <summary>
/// Either external function or member name.
/// </summary>
/// <returns></returns>
public object VisitMemberAccess(MemberAccessExpr expr)
{
var memberAccess = MemberHelper.GetMemberAccess(expr, this.Ctx, expr.VarExp, expr.MemberName, this);
if (expr.IsAssignment)
{
return(memberAccess);
}
if (memberAccess.MemberMissing)
{
throw expr.BuildRunTimeException("Member : " + expr.MemberName + " does not exist");
}
// NOTES:
// 1. If property on a built in type && not assignment then just return the value of the property
// 2. It's done here instead because there is no function/method call on a property.
if (memberAccess.IsPropertyAccessOnBuiltInType())
{
var result = FunctionHelper.CallMemberOnBasicType(this.Ctx, expr, memberAccess, null, null, this);
return(result);
}
if (memberAccess.IsPropertyAccessOnClass() || memberAccess.IsFieldAccessOnClass())
{
var result = FunctionHelper.CallMemberOnClass(this.Ctx, expr, memberAccess, null, null, this);
return(result);
}
if (memberAccess.IsModuleAccess())
{
var result = MemberHelper.ResolveSymbol(memberAccess.Scope, expr.MemberName);
return(result);
}
return(memberAccess);
}
public void TestMemberAccessExpr()
{
// not (1 > 2)
var programSource = new TokenList()
{
{ TokenType.Identifier, "x" },
{ TokenType.OpAssignment },
{ TokenType.Identifier, "arr" },
{ TokenType.OpDot },
{ TokenType.Identifier, "size" }
};
Parser parser = new Parser(CreateMockScanner(programSource), new ErrorHandler());
ProgramNode program = parser.Parse();
var expr = new MemberAccessExpr(0, 0);
expr.AccessedExpr = new VariableExpr(0, 0, "arr");
expr.MemberId = "size";
var assignment = new AssignmentStmt(0, 0);
assignment.AssignmentExpr = expr;
assignment.Variable = new VariableExpr(0, 0, "x");
expected.Block.Statements.Add(assignment);
program.ShouldBeEquivalentTo(expected);
}
private Tuple <bool, Expr> IsMatch(FluentPluginHelper helper, Type type, Token klass, Token instance, Token prop, Token method)
{
string memberName = null;
string rootVar = null;
bool match = false;
// 1. Class property
if (klass != null && prop != null)
{
rootVar = klass.Text;
if (helper.IsClassProp(type, prop.Text))
{
memberName = prop.Text;
match = true;
}
}
// 2. Class method
else if (klass != null && method != null)
{
rootVar = type.Name;
if (helper.IsClassMethod(type, method.Text))
{
memberName = method.Text;
match = true;
}
}
// 3. Instance property
else if (instance != null && prop != null)
{
rootVar = instance.Text;
if (helper.IsInstanceProp(type, prop.Text))
{
memberName = prop.Text;
match = true;
}
}
// 4. Instance method
else if (instance != null && method != null)
{
rootVar = instance.Text;
if (helper.IsInstanceMethod(type, method.Text))
{
memberName = method.Text;
match = true;
}
}
if (!match)
{
return(new Tuple <bool, Expr>(false, null));
}
var varExp = new VariableExpr(rootVar);
varExp.Ctx = _parser.Context;
var memExp = new MemberAccessExpr(varExp, memberName, false);
memExp.Ctx = _parser.Context;
return(new Tuple <bool, Expr>(memberName != null, memExp));
}
/// <summary>
/// Creates a function call expression.
/// </summary>
/// <param name="nameExpr"></param>
/// <param name="parameters"></param>
/// <param name="token"></param>
/// <returns></returns>
public static Expr MemberAccess(Expr nameExpr, string memberName, bool isAssignment, TokenData token)
{
var exp = new MemberAccessExpr();
exp.IsAssignment = isAssignment;
exp.VarExp = nameExpr;
exp.MemberName = memberName;
SetupContext(exp, token);
return(exp);
}
public FunctionCallExpr BuildFuncCallExpr(Context ctx, string varName, string memName, List <object> args)
{
var exp = new FunctionCallExpr();
var memExp = new MemberAccessExpr(new VariableExpr(varName), memName, false);
memExp.Ctx = ctx;
((VariableExpr)memExp.VariableExp).Ctx = ctx;
exp.NameExp = memExp;
exp.ParamList = args;
exp.Ctx = ctx;
return(exp);
}
public void TestAccessSizeOfNotArray()
{
var program = new ProgramNode(0, 0);
program.Block = new BlockStmt(0, 0);
var declaration = CreateVarDeclaration("var1", new ArrayType(0, 0, ExprType.Int));
var assign = new AssignmentStmt(0, 0);
assign.Variable = new VariableExpr(0, 0, "var1");
var access = new MemberAccessExpr(0, 0);
access.AccessedExpr = new IntLiteralExpr(0, 0, 1);
access.MemberId = "size";
assign.AssignmentExpr = access;
program.Block.Statements.Add(declaration);
program.Block.Statements.Add(assign);
AssertErrorContains(program, "Int has no member 'size'");
}
public void TestAccessArraySize()
{
var program = new ProgramNode(0, 0);
program.Block = new BlockStmt(0, 0);
var declaration = CreateVarDeclaration("var1", new ArrayType(0, 0, ExprType.Int));
var declaration2 = CreateVarDeclaration("var2");
var assign = new AssignmentStmt(0, 0);
var member = new MemberAccessExpr(0, 0);
member.AccessedExpr = new VariableExpr(0, 0, "var1");
member.MemberId = "size";
assign.Variable = new VariableExpr(0, 0, "var2");
assign.AssignmentExpr = member;
program.Block.Statements.Add(declaration);
program.Block.Statements.Add(declaration2);
program.Block.Statements.Add(assign);
AssertNoErrors(program);
}
/// <summary>
/// Visits the function call expression tree
/// </summary>
/// <param name="exp"></param>
public object VisitMemberAccess(MemberAccessExpr exp)
{
return(null);
}
