public string SetTypeName(VBAParser.ExpressionContext expression, QualifiedModuleName containingModule)
{
if (expression == null)
{
return(null);
}
switch (expression)
{
case VBAParser.LExprContext lExpression:
return(SetTypeName(lExpression.lExpression(), containingModule));
case VBAParser.NewExprContext newExpression:
return(SetTypeName(newExpression.expression(), containingModule));
case VBAParser.TypeofexprContext typeOfExpression:
return(SetTypeName(typeOfExpression.expression(), containingModule));
case VBAParser.LiteralExprContext literalExpression:
return(SetTypeName(literalExpression.literalExpression()));
case VBAParser.BuiltInTypeExprContext builtInTypeExpression:
return(SetTypeName(builtInTypeExpression.builtInType()));
default:
return(NotAnObject); //All remaining expression types have no Set type.
}
}
public static bool IsBinaryMathContext(this VBAParser.ExpressionContext context)
{
return(context is VBAParser.MultOpContext || //MultOpContext includes both * and /
context is VBAParser.AddOpContext || //AddOpContet includes both + and -
context is VBAParser.PowOpContext ||
context is VBAParser.IntDivOpContext ||
context is VBAParser.ModOpContext);
}
public static bool IsBinaryLogicalContext(this VBAParser.ExpressionContext context)
{
return(context is VBAParser.RelationalOpContext ||
context is VBAParser.LogicalXorOpContext ||
context is VBAParser.LogicalAndOpContext ||
context is VBAParser.LogicalOrOpContext ||
context is VBAParser.LogicalImpOpContext ||
context is VBAParser.LogicalEqvOpContext);
}
private static bool HasProcedureCall(VBAParser.ExpressionContext context, out string argList)
{
// bug: what if complex expression has multiple arg lists?
argList = GetArgListString(context.FindChildren <VBAParser.ArgListContext>().FirstOrDefault())
?? GetArgListString(context.FindChildren <VBAParser.ArgumentListContext>().FirstOrDefault());
return(!(context is VBAParser.LiteralExprContext ||
context is VBAParser.NewExprContext ||
context is VBAParser.BuiltInTypeExprContext));
}
private IExpressionBinding Visit(Declaration module, Declaration parent, VBAParser.ExpressionContext expression)
{
switch (expression)
{
case VBAParser.LExprContext lExprContext:
return(Visit(module, parent, lExprContext.lExpression()));
default:
throw new NotSupportedException($"Unexpected expression type {expression.GetType()}");
}
}
private IExpressionBinding VisitTypeOf(
Declaration module,
Declaration parent,
VBAParser.RelationalOpContext typeOfIsExpression,
VBAParser.TypeofexprContext typeOfLeftPartExpression,
VBAParser.ExpressionContext typeExpression,
IBoundExpression withBlockVariable)
{
var booleanExpression = typeOfLeftPartExpression.expression();
var booleanExpressionBinding = Visit(module, parent, booleanExpression, withBlockVariable, StatementResolutionContext.Undefined);
var typeExpressionBinding = VisitType(module, parent, typeExpression, withBlockVariable);
return(new TypeOfIsDefaultBinding(typeOfIsExpression, booleanExpressionBinding, typeExpressionBinding));
}
public static bool TryGetRelationalOpContextSymbol(this VBAParser.ExpressionContext context, out string opSymbol)
{
switch (context)
{
case VBAParser.RelationalOpContext ctxt:
var terminalNode = ctxt.EQ() ?? ctxt.GEQ() ?? ctxt.GT() ?? ctxt.LEQ()
?? ctxt.LIKE() ?? ctxt.LT() ?? ctxt.NEQ();
opSymbol = terminalNode.GetText();
return(true);
default:
opSymbol = string.Empty;
return(false);
}
}
public Declaration SetTypeDeclaration(VBAParser.ExpressionContext expression, QualifiedModuleName containingModule)
{
if (expression == null)
{
return(null);
}
switch (expression)
{
case VBAParser.LExprContext lExpression:
return(SetTypeDeclaration(lExpression.lExpression(), containingModule));
case VBAParser.NewExprContext newExpression:
return(SetTypeDeclaration(newExpression.expression(), containingModule));
case VBAParser.TypeofexprContext typeOfExpression:
return(SetTypeDeclaration(typeOfExpression.expression(), containingModule));
default:
return(null); //All remaining expression types either have no Set type or there is no declaration for it.
}
}
public static bool TryGetLogicalContextSymbol(this VBAParser.ExpressionContext context, out string symbol)
{
if (context.TryGetRelationalOpContextSymbol(out symbol))
{
return(true);
}
switch (context)
{
case VBAParser.LogicalXorOpContext _:
symbol = context.GetToken(VBAParser.XOR, 0).GetText();
return(true);
case VBAParser.LogicalAndOpContext _:
symbol = context.GetToken(VBAParser.AND, 0).GetText();
return(true);
case VBAParser.LogicalOrOpContext _:
symbol = context.GetToken(VBAParser.OR, 0).GetText();
return(true);
case VBAParser.LogicalEqvOpContext _:
symbol = context.GetToken(VBAParser.EQV, 0).GetText();
return(true);
case VBAParser.LogicalImpOpContext _:
symbol = context.GetToken(VBAParser.IMP, 0).GetText();
return(true);
case VBAParser.LogicalNotOpContext _:
symbol = context.GetToken(VBAParser.NOT, 0).GetText();
return(true);
default:
symbol = string.Empty;
return(false);
}
}
private IExpressionBinding VisitType(Declaration module, Declaration parent, VBAParser.ExpressionContext expression, IBoundExpression withBlockVariable)
{
return(_typeBindingContext.BuildTree(module, parent, expression, withBlockVariable, StatementResolutionContext.Undefined));
}
private IExpressionBinding Visit(Declaration module, Declaration parent, VBAParser.ExpressionContext expression, IBoundExpression withBlockVariable, StatementResolutionContext statementContext)
{
switch (expression)
{
case VBAParser.LExprContext lExprContext:
return(Visit(module, parent, lExprContext.lExpression(), withBlockVariable, statementContext));
case VBAParser.ParenthesizedExprContext parenthesizedExprContext:
return(Visit(module, parent, parenthesizedExprContext, withBlockVariable));
case VBAParser.RelationalOpContext relationalOpContext:
return(Visit(module, parent, relationalOpContext, withBlockVariable));
case VBAParser.LiteralExprContext literalExprContext:
return(Visit(literalExprContext.literalExpression()));
case VBAParser.NewExprContext newExprContext:
return(Visit(module, parent, newExprContext, withBlockVariable));
case VBAParser.LogicalNotOpContext logicalNotOpContext:
return(VisitUnaryOp(module, parent, logicalNotOpContext, logicalNotOpContext.expression(), withBlockVariable));
case VBAParser.UnaryMinusOpContext unaryMinusOpContext:
return(VisitUnaryOp(module, parent, unaryMinusOpContext, unaryMinusOpContext.expression(), withBlockVariable));
case VBAParser.LogicalAndOpContext logicalAndOpContext:
return(VisitBinaryOp(module, parent, logicalAndOpContext, logicalAndOpContext.expression()[0], logicalAndOpContext.expression()[1], withBlockVariable));
case VBAParser.LogicalOrOpContext logicalOrOpContext:
return(VisitBinaryOp(module, parent, logicalOrOpContext, logicalOrOpContext.expression()[0], logicalOrOpContext.expression()[1], withBlockVariable));
case VBAParser.LogicalXorOpContext logicalXorOpContext:
return(VisitBinaryOp(module, parent, logicalXorOpContext, logicalXorOpContext.expression()[0], logicalXorOpContext.expression()[1], withBlockVariable));
case VBAParser.LogicalEqvOpContext logicalEqvOpContext:
return(VisitBinaryOp(module, parent, logicalEqvOpContext, logicalEqvOpContext.expression()[0], logicalEqvOpContext.expression()[1], withBlockVariable));
case VBAParser.LogicalImpOpContext logicalImpOpContext:
return(VisitBinaryOp(module, parent, logicalImpOpContext, logicalImpOpContext.expression()[0], logicalImpOpContext.expression()[1], withBlockVariable));
case VBAParser.AddOpContext addOpContext:
return(VisitBinaryOp(module, parent, addOpContext, addOpContext.expression()[0], addOpContext.expression()[1], withBlockVariable));
case VBAParser.ConcatOpContext concatOpContext:
return(VisitBinaryOp(module, parent, concatOpContext, concatOpContext.expression()[0], concatOpContext.expression()[1], withBlockVariable));
case VBAParser.MultOpContext multOpContext:
return(VisitBinaryOp(module, parent, multOpContext, multOpContext.expression()[0], multOpContext.expression()[1], withBlockVariable));
case VBAParser.ModOpContext modOpContext:
return(VisitBinaryOp(module, parent, modOpContext, modOpContext.expression()[0], modOpContext.expression()[1], withBlockVariable));
case VBAParser.PowOpContext powOpContext:
return(VisitBinaryOp(module, parent, powOpContext, powOpContext.expression()[0], powOpContext.expression()[1], withBlockVariable));
case VBAParser.IntDivOpContext intDivOpContext:
return(VisitBinaryOp(module, parent, intDivOpContext, intDivOpContext.expression()[0], intDivOpContext.expression()[1], withBlockVariable));
case VBAParser.MarkedFileNumberExprContext markedFileNumberExprContext:
return(Visit(module, parent, markedFileNumberExprContext, withBlockVariable));
case VBAParser.BuiltInTypeExprContext builtInTypeExprContext:
return(Visit(builtInTypeExprContext));
//We do not handle the VBAParser.TypeofexprContext because that should only ever appear as a child of an IS relational operator expression and is specifically handled there.
default:
throw new NotSupportedException($"Unexpected expression type {expression.GetType()}");
}
}
public static bool IsMathContext(this VBAParser.ExpressionContext context)
{
return(context.IsBinaryMathContext() || context.IsUnaryMathContext());
}
private IExpressionBinding VisitUnaryOp(Declaration module, Declaration parent, ParserRuleContext context, VBAParser.ExpressionContext expr, IBoundExpression withBlockVariable)
{
var exprBinding = Visit(module, parent, expr, withBlockVariable, StatementResolutionContext.Undefined);
var letCoercionBinding = new LetCoercionDefaultBinding(expr, exprBinding);
return(new UnaryOpDefaultBinding(context, letCoercionBinding));
}
public static bool IsUnaryLogicalContext(this VBAParser.ExpressionContext context)
{
return(context is VBAParser.LogicalNotOpContext);
}
public static bool IsUnaryMathContext(this VBAParser.ExpressionContext context)
{
return(context is VBAParser.UnaryMinusOpContext);
}
private IExpressionBinding VisitBinaryOp(Declaration module, Declaration parent, ParserRuleContext context, VBAParser.ExpressionContext left, VBAParser.ExpressionContext right, IBoundExpression withBlockVariable, bool isIsRelation = false)
{
var leftBinding = Visit(module, parent, left, withBlockVariable, StatementResolutionContext.Undefined);
var rightBinding = Visit(module, parent, right, withBlockVariable, StatementResolutionContext.Undefined);
if (!isIsRelation)
{
//All but the Is relation require value type arguments.
leftBinding = new LetCoercionDefaultBinding(left, leftBinding);
rightBinding = new LetCoercionDefaultBinding(right, rightBinding);
}
return(new BinaryOpDefaultBinding(context, leftBinding, rightBinding));
}
private IExpressionBinding Visit(Declaration module, Declaration parent, VBAParser.ExpressionContext expression)
{
return(Visit(module, parent, (dynamic)expression));
}
private string SetTypeNameOfExpression(VBAParser.ExpressionContext expression, QualifiedModuleName containingModule, DeclarationFinder finder)
{
return(_setTypeResolver.SetTypeName(expression, containingModule));
}
public static bool IsLogicalContext(this VBAParser.ExpressionContext context)
{
return(TryGetLogicalContextSymbol(context, out _));
}
