public override Expr Visit( AccessorMemberExpr e )
{
if( _unboundCollector != null )
{
if( e.IsUnbound ) _unboundCollector( e );
else VisitExpr( e.Left );
}
return e;
}
public void SimpleExpression()
{
Analyzer a = new Analyzer();
Tokenizer p = new Tokenizer();
{
p.Reset("value");
p.IsErrorOrEndOfInput.Should().Be(false);
Expr e = a.Analyse(p);
e.Should().BeOfType <AccessorMemberExpr>();
AccessorMemberExpr ac = e as AccessorMemberExpr;
ac.IsUnbound.Should().Be(true);
}
{
p.Reset("!");
Expr e = a.Analyse(p);
e.Should().BeOfType <UnaryExpr>();
UnaryExpr u = e as UnaryExpr;
u.TokenType.Should().Be(TokenizerToken.Not);
u.Expression.Should().BeOfType <SyntaxErrorExpr>();
SyntaxErrorCollector.Collect(e, null).Count.Should().Be(1);
}
{
p.Reset("!value");
Expr e = a.Analyse(p);
e.Should().BeOfType <UnaryExpr>();
UnaryExpr u = e as UnaryExpr;
u.TokenType.Should().Be(TokenizerToken.Not);
u.Expression.Should().BeOfType <AccessorMemberExpr>();
SyntaxErrorCollector.Collect(e, null).Should().BeEmpty();
}
{
p.Reset(" 0.12e43 && ~b ");
Expr e = a.Analyse(p);
e.Should().BeOfType <BinaryExpr>();
BinaryExpr and = e as BinaryExpr;
and.BinaryOperatorToken.Should().Be(TokenizerToken.And);
IsConstant(and.Left, 0.12e43);
and.Right.Should().BeOfType <UnaryExpr>();
UnaryExpr u = and.Right as UnaryExpr;
u.TokenType.Should().Be(TokenizerToken.BitwiseNot);
u.Expression.Should().BeOfType <AccessorMemberExpr>();
AccessorMemberExpr m = u.Expression as AccessorMemberExpr;
m.Left.Should().BeNull();
SyntaxErrorCollector.Collect(e, null).Should().BeEmpty();
}
{
p.Reset(@"!a||~""x""");
Expr e = a.Analyse(p);
e.Should().BeOfType <BinaryExpr>();
BinaryExpr or = e as BinaryExpr;
or.BinaryOperatorToken.Should().Be(TokenizerToken.Or);
or.Left.Should().BeOfType <UnaryExpr>();
or.Right.Should().BeOfType <UnaryExpr>();
UnaryExpr u = or.Right as UnaryExpr;
u.TokenType.Should().Be(TokenizerToken.BitwiseNot);
IsConstant(u.Expression, "x");
SyntaxErrorCollector.Collect(e, null).Should().BeEmpty();
}
{
p.Reset("(3)");
Expr e = a.Analyse(p);
IsConstant(e, 3.0);
}
{
p.Reset("(3+typeof 'x')");
Expr e = a.Analyse(p);
e.Should().BeOfType <BinaryExpr>();
BinaryExpr b = e as BinaryExpr;
IsConstant(b.Left, 3.0);
b.Right.Should().BeOfType <UnaryExpr>();
UnaryExpr u = b.Right as UnaryExpr;
u.TokenType.Should().Be(TokenizerToken.TypeOf);
IsConstant(u.Expression, "x");
SyntaxErrorCollector.Collect(e, null).Should().BeEmpty();
}
{
p.Reset("1 ? 2 : 3");
Expr e = a.Analyse(p);
e.Should().BeOfType <IfExpr>();
IfExpr i = e as IfExpr;
i.IsTernaryOperator.Should().Be(true);
IsConstant(i.Condition, 1.0);
IsConstant(i.WhenTrue, 2.0);
IsConstant(i.WhenFalse, 3.0);
}
}
public void SimpleExpression()
{
ExprAnalyser a = new ExprAnalyser();
JSTokenizer p = new JSTokenizer();
{
p.Reset("value");
Assert.That(p.IsErrorOrEndOfInput, Is.False);
Expr e = a.Analyse(p);
Assert.That(e is AccessorMemberExpr);
AccessorMemberExpr ac = e as AccessorMemberExpr;
Assert.That(ac.IsUnbound == true);
}
{
p.Reset("!");
Expr e = a.Analyse(p);
Assert.That(e is UnaryExpr);
UnaryExpr u = e as UnaryExpr;
Assert.That(u.TokenType == JSTokenizerToken.Not);
Assert.That(u.Expression is SyntaxErrorExpr);
Assert.That(SyntaxErrorCollector.Collect(e, null).Count == 1);
}
{
p.Reset("!value");
Expr e = a.Analyse(p);
Assert.That(e is UnaryExpr);
UnaryExpr u = e as UnaryExpr;
Assert.That(u.TokenType == JSTokenizerToken.Not);
Assert.That(u.Expression is AccessorExpr);
Assert.That(SyntaxErrorCollector.Collect(e, Util.ActionVoid).Count == 0);
}
{
p.Reset(" 0.12e43 && ~b ");
Expr e = a.Analyse(p);
Assert.That(e is BinaryExpr);
BinaryExpr and = e as BinaryExpr;
Assert.That(and.BinaryOperatorToken == JSTokenizerToken.And);
IsConstant(and.Left, 0.12e43);
Assert.That(and.Right is UnaryExpr);
UnaryExpr u = and.Right as UnaryExpr;
Assert.That(u.TokenType == JSTokenizerToken.BitwiseNot);
Assert.That(u.Expression is AccessorExpr);
Assert.That(SyntaxErrorCollector.Collect(e, Util.ActionVoid).Count == 0);
}
{
p.Reset(@"!a||~""x""");
Expr e = a.Analyse(p);
Assert.That(e is BinaryExpr);
BinaryExpr or = e as BinaryExpr;
Assert.That(or.BinaryOperatorToken == JSTokenizerToken.Or);
Assert.That(or.Left is UnaryExpr);
Assert.That(or.Right is UnaryExpr);
UnaryExpr u = or.Right as UnaryExpr;
Assert.That(u.TokenType == JSTokenizerToken.BitwiseNot);
IsConstant(u.Expression, "x");
Assert.That(SyntaxErrorCollector.Collect(e, Util.ActionVoid).Count == 0);
}
{
p.Reset("(3)");
Expr e = a.Analyse(p);
IsConstant(e, 3);
}
{
p.Reset("(3+typeof 'x')");
Expr e = a.Analyse(p);
Assert.That(e is BinaryExpr);
BinaryExpr b = e as BinaryExpr;
IsConstant(b.Left, 3);
Assert.That(b.Right is UnaryExpr);
UnaryExpr u = b.Right as UnaryExpr;
Assert.That(u.TokenType == JSTokenizerToken.TypeOf);
IsConstant(u.Expression, "x");
Assert.That(SyntaxErrorCollector.Collect(e, Util.ActionVoid).Count == 0);
}
{
p.Reset("1 ? 2 : 3");
Expr e = a.Analyse(p);
Assert.That(e is IfExpr);
IfExpr i = e as IfExpr;
Assert.That(i.IsTernaryOperator == true);
IsConstant(i.Condition, 1);
IsConstant(i.WhenTrue, 2);
IsConstant(i.WhenFalse, 3);
}
}
