AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity
8bd393090d
v8/test/cctest/test-ast-expression-visitor.cc
jochen 6f472db65a Disable soon to be deprecated APIs per default for v8 
Embedders still can use those APIs by default

test-api.cc still has an exception to use the old APIs...

BUG=v8:4143
R=vogelheim@chromium.org
LOG=n

Review URL: https://codereview.chromium.org/1505803004

Cr-Commit-Position: refs/heads/master@{#32701}
2015-12-09 10:35:04 +00:00

420 lines
14 KiB
C++
Raw Blame History

// Copyright 2015 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <stdlib.h>
#include "src/v8.h"
#include "src/ast/ast.h"
#include "src/ast/ast-expression-visitor.h"
#include "src/ast/scopes.h"
#include "src/parsing/parser.h"
#include "src/parsing/rewriter.h"
#include "test/cctest/cctest.h"
#include "test/cctest/expression-type-collector.h"
#include "test/cctest/expression-type-collector-macros.h"
using namespace v8::internal;
namespace {
static void CollectTypes(HandleAndZoneScope* handles, const char* source,
ZoneVector<ExpressionTypeEntry>* dst) {
i::Isolate* isolate = CcTest::i_isolate();
i::Factory* factory = isolate->factory();
i::Handle<i::String> source_code =
factory->NewStringFromUtf8(i::CStrVector(source)).ToHandleChecked();
i::Handle<i::Script> script = factory->NewScript(source_code);
i::ParseInfo info(handles->main_zone(), script);
i::Parser parser(&info);
parser.set_allow_harmony_sloppy(true);
info.set_global();
info.set_lazy(false);
info.set_allow_lazy_parsing(false);
info.set_toplevel(true);
CHECK(i::Compiler::ParseAndAnalyze(&info));
ExpressionTypeCollector(
isolate,
info.scope()->declarations()->at(0)->AsFunctionDeclaration()->fun(), dst)
.Run();
}
} // namespace
TEST(VisitExpressions) {
v8::V8::Initialize();
HandleAndZoneScope handles;
ZoneVector<ExpressionTypeEntry> types(handles.main_zone());
const char test_function[] =
"function GeometricMean(stdlib, foreign, buffer) {\n"
" \"use asm\";\n"
"\n"
" var exp = stdlib.Math.exp;\n"
" var log = stdlib.Math.log;\n"
" var values = new stdlib.Float64Array(buffer);\n"
"\n"
" function logSum(start, end) {\n"
" start = start|0;\n"
" end = end|0;\n"
"\n"
" var sum = 0.0, p = 0, q = 0;\n"
"\n"
" // asm.js forces byte addressing of the heap by requiring shifting "
"by 3\n"
" for (p = start << 3, q = end << 3; (p|0) < (q|0); p = (p + 8)|0) {\n"
" sum = sum + +log(values[p>>3]);\n"
" }\n"
"\n"
" return +sum;\n"
" }\n"
"\n"
" function geometricMean(start, end) {\n"
" start = start|0;\n"
" end = end|0;\n"
"\n"
" return +exp(+logSum(start, end) / +((end - start)|0));\n"
" }\n"
"\n"
" return { geometricMean: geometricMean };\n"
"}\n";
CollectTypes(&handles, test_function, &types);
CHECK_TYPES_BEGIN {
// function logSum
CHECK_EXPR(FunctionLiteral, Bounds::Unbounded()) {
CHECK_EXPR(FunctionLiteral, Bounds::Unbounded()) {
CHECK_EXPR(Assignment, Bounds::Unbounded()) {
CHECK_VAR(start, Bounds::Unbounded());
CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
CHECK_VAR(start, Bounds::Unbounded());
CHECK_EXPR(Literal, Bounds::Unbounded());
}
}
CHECK_EXPR(Assignment, Bounds::Unbounded()) {
CHECK_VAR(end, Bounds::Unbounded());
CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
CHECK_VAR(end, Bounds::Unbounded());
CHECK_EXPR(Literal, Bounds::Unbounded());
}
}
CHECK_EXPR(Assignment, Bounds::Unbounded()) {
CHECK_VAR(sum, Bounds::Unbounded());
CHECK_EXPR(Literal, Bounds::Unbounded());
}
CHECK_EXPR(Assignment, Bounds::Unbounded()) {
CHECK_VAR(p, Bounds::Unbounded());
CHECK_EXPR(Literal, Bounds::Unbounded());
}
CHECK_EXPR(Assignment, Bounds::Unbounded()) {
CHECK_VAR(q, Bounds::Unbounded());
CHECK_EXPR(Literal, Bounds::Unbounded());
}
// for (p = start << 3, q = end << 3;
CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
CHECK_EXPR(Assignment, Bounds::Unbounded()) {
CHECK_VAR(p, Bounds::Unbounded());
CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
CHECK_VAR(start, Bounds::Unbounded());
CHECK_EXPR(Literal, Bounds::Unbounded());
}
}
CHECK_EXPR(Assignment, Bounds::Unbounded()) {
CHECK_VAR(q, Bounds::Unbounded());
CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
CHECK_VAR(end, Bounds::Unbounded());
CHECK_EXPR(Literal, Bounds::Unbounded());
}
}
}
// (p|0) < (q|0);
CHECK_EXPR(CompareOperation, Bounds::Unbounded()) {
CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
CHECK_VAR(p, Bounds::Unbounded());
CHECK_EXPR(Literal, Bounds::Unbounded());
}
CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
CHECK_VAR(q, Bounds::Unbounded());
CHECK_EXPR(Literal, Bounds::Unbounded());
}
}
// p = (p + 8)|0) {\n"
CHECK_EXPR(Assignment, Bounds::Unbounded()) {
CHECK_VAR(p, Bounds::Unbounded());
CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
CHECK_VAR(p, Bounds::Unbounded());
CHECK_EXPR(Literal, Bounds::Unbounded());
}
CHECK_EXPR(Literal, Bounds::Unbounded());
}
}
// sum = sum + +log(values[p>>3]);
CHECK_EXPR(Assignment, Bounds::Unbounded()) {
CHECK_VAR(sum, Bounds::Unbounded());
CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
CHECK_VAR(sum, Bounds::Unbounded());
CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
CHECK_EXPR(Call, Bounds::Unbounded()) {
CHECK_VAR(log, Bounds::Unbounded());
CHECK_EXPR(Property, Bounds::Unbounded()) {
CHECK_VAR(values, Bounds::Unbounded());
CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
CHECK_VAR(p, Bounds::Unbounded());
CHECK_EXPR(Literal, Bounds::Unbounded());
}
}
}
CHECK_EXPR(Literal, Bounds::Unbounded());
}
}
}
// return +sum;
CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
CHECK_VAR(sum, Bounds::Unbounded());
CHECK_EXPR(Literal, Bounds::Unbounded());
}
}
// function geometricMean
CHECK_EXPR(FunctionLiteral, Bounds::Unbounded()) {
CHECK_EXPR(Assignment, Bounds::Unbounded()) {
CHECK_VAR(start, Bounds::Unbounded());
CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
CHECK_VAR(start, Bounds::Unbounded());
CHECK_EXPR(Literal, Bounds::Unbounded());
}
}
CHECK_EXPR(Assignment, Bounds::Unbounded()) {
CHECK_VAR(end, Bounds::Unbounded());
CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
CHECK_VAR(end, Bounds::Unbounded());
CHECK_EXPR(Literal, Bounds::Unbounded());
}
}
// return +exp(+logSum(start, end) / +((end - start)|0));
CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
CHECK_EXPR(Call, Bounds::Unbounded()) {
CHECK_VAR(exp, Bounds::Unbounded());
CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
CHECK_EXPR(Call, Bounds::Unbounded()) {
CHECK_VAR(logSum, Bounds::Unbounded());
CHECK_VAR(start, Bounds::Unbounded());
CHECK_VAR(end, Bounds::Unbounded());
}
CHECK_EXPR(Literal, Bounds::Unbounded());
}
CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
CHECK_VAR(end, Bounds::Unbounded());
CHECK_VAR(start, Bounds::Unbounded());
}
CHECK_EXPR(Literal, Bounds::Unbounded());
}
CHECK_EXPR(Literal, Bounds::Unbounded());
}
}
}
CHECK_EXPR(Literal, Bounds::Unbounded());
}
}
// "use asm";
CHECK_EXPR(Literal, Bounds::Unbounded());
// var exp = stdlib.Math.exp;
CHECK_EXPR(Assignment, Bounds::Unbounded()) {
CHECK_VAR(exp, Bounds::Unbounded());
CHECK_EXPR(Property, Bounds::Unbounded()) {
CHECK_EXPR(Property, Bounds::Unbounded()) {
CHECK_VAR(stdlib, Bounds::Unbounded());
CHECK_EXPR(Literal, Bounds::Unbounded());
}
CHECK_EXPR(Literal, Bounds::Unbounded());
}
}
// var log = stdlib.Math.log;
CHECK_EXPR(Assignment, Bounds::Unbounded()) {
CHECK_VAR(log, Bounds::Unbounded());
CHECK_EXPR(Property, Bounds::Unbounded()) {
CHECK_EXPR(Property, Bounds::Unbounded()) {
CHECK_VAR(stdlib, Bounds::Unbounded());
CHECK_EXPR(Literal, Bounds::Unbounded());
}
CHECK_EXPR(Literal, Bounds::Unbounded());
}
}
// var values = new stdlib.Float64Array(buffer);
CHECK_EXPR(Assignment, Bounds::Unbounded()) {
CHECK_VAR(values, Bounds::Unbounded());
CHECK_EXPR(CallNew, Bounds::Unbounded()) {
CHECK_EXPR(Property, Bounds::Unbounded()) {
CHECK_VAR(stdlib, Bounds::Unbounded());
CHECK_EXPR(Literal, Bounds::Unbounded());
}
CHECK_VAR(buffer, Bounds::Unbounded());
}
}
// return { geometricMean: geometricMean };
CHECK_EXPR(ObjectLiteral, Bounds::Unbounded()) {
CHECK_VAR(geometricMean, Bounds::Unbounded());
}
}
}
CHECK_TYPES_END
}
TEST(VisitConditional) {
v8::V8::Initialize();
HandleAndZoneScope handles;
ZoneVector<ExpressionTypeEntry> types(handles.main_zone());
// Check that traversing the ternary operator works.
const char test_function[] =
"function foo() {\n"
" var a, b, c;\n"
" var x = a ? b : c;\n"
"}\n";
CollectTypes(&handles, test_function, &types);
CHECK_TYPES_BEGIN {
CHECK_EXPR(FunctionLiteral, Bounds::Unbounded()) {
CHECK_EXPR(Assignment, Bounds::Unbounded()) {
CHECK_VAR(x, Bounds::Unbounded());
CHECK_EXPR(Conditional, Bounds::Unbounded()) {
CHECK_VAR(a, Bounds::Unbounded());
CHECK_VAR(b, Bounds::Unbounded());
CHECK_VAR(c, Bounds::Unbounded());
}
}
}
}
CHECK_TYPES_END
}
TEST(VisitEmptyForStatment) {
v8::V8::Initialize();
HandleAndZoneScope handles;
ZoneVector<ExpressionTypeEntry> types(handles.main_zone());
// Check that traversing an empty for statement works.
const char test_function[] =
"function foo() {\n"
" for (;;) {}\n"
"}\n";
CollectTypes(&handles, test_function, &types);
CHECK_TYPES_BEGIN {
CHECK_EXPR(FunctionLiteral, Bounds::Unbounded()) {}
}
CHECK_TYPES_END
}
TEST(VisitSwitchStatment) {
v8::V8::Initialize();
HandleAndZoneScope handles;
ZoneVector<ExpressionTypeEntry> types(handles.main_zone());
// Check that traversing a switch with a default works.
const char test_function[] =
"function foo() {\n"
" switch (0) { case 1: break; default: break; }\n"
"}\n";
CollectTypes(&handles, test_function, &types);
CHECK_TYPES_BEGIN {
CHECK_EXPR(FunctionLiteral, Bounds::Unbounded()) {
CHECK_EXPR(Assignment, Bounds::Unbounded()) {
CHECK_VAR(.switch_tag, Bounds::Unbounded());
CHECK_EXPR(Literal, Bounds::Unbounded());
}
CHECK_EXPR(Literal, Bounds::Unbounded());
CHECK_VAR(.switch_tag, Bounds::Unbounded());
CHECK_EXPR(Literal, Bounds::Unbounded());
}
}
CHECK_TYPES_END
}
TEST(VisitThrow) {
v8::V8::Initialize();
HandleAndZoneScope handles;
ZoneVector<ExpressionTypeEntry> types(handles.main_zone());
// Check that traversing an empty for statement works.
const char test_function[] =
"function foo() {\n"
" throw 123;\n"
"}\n";
CollectTypes(&handles, test_function, &types);
CHECK_TYPES_BEGIN {
CHECK_EXPR(FunctionLiteral, Bounds::Unbounded()) {
CHECK_EXPR(Throw, Bounds::Unbounded()) {
CHECK_EXPR(Literal, Bounds::Unbounded());
}
}
}
CHECK_TYPES_END
}
TEST(VisitYield) {
v8::V8::Initialize();
HandleAndZoneScope handles;
ZoneVector<ExpressionTypeEntry> types(handles.main_zone());
// Check that traversing an empty for statement works.
const char test_function[] =
"function* foo() {\n"
" yield 123;\n"
"}\n";
CollectTypes(&handles, test_function, &types);
CHECK_TYPES_BEGIN {
CHECK_EXPR(FunctionLiteral, Bounds::Unbounded()) {
// Generator function yields generator on entry.
CHECK_EXPR(Yield, Bounds::Unbounded()) {
CHECK_VAR(.generator_object, Bounds::Unbounded());
CHECK_EXPR(Assignment, Bounds::Unbounded()) {
CHECK_VAR(.generator_object, Bounds::Unbounded());
CHECK_EXPR(CallRuntime, Bounds::Unbounded());
}
}
// Then yields undefined.
CHECK_EXPR(Yield, Bounds::Unbounded()) {
CHECK_VAR(.generator_object, Bounds::Unbounded());
CHECK_EXPR(Literal, Bounds::Unbounded());
}
// Then yields 123.
CHECK_EXPR(Yield, Bounds::Unbounded()) {
CHECK_VAR(.generator_object, Bounds::Unbounded());
CHECK_EXPR(Literal, Bounds::Unbounded());
}
}
}
CHECK_TYPES_END
}
TEST(VisitSkipping) {
v8::V8::Initialize();
HandleAndZoneScope handles;
ZoneVector<ExpressionTypeEntry> types(handles.main_zone());
// Check that traversing an empty for statement works.
const char test_function[] =
"function foo(x) {\n"
" return (x + x) + 1;\n"
"}\n";
CollectTypes(&handles, test_function, &types);
CHECK_TYPES_BEGIN {
CHECK_EXPR(FunctionLiteral, Bounds::Unbounded()) {
CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
// Skip x + x
CHECK_SKIP();
CHECK_EXPR(Literal, Bounds::Unbounded());
}
}
}
CHECK_TYPES_END
}
Reference in New Issue View Git Blame Copy Permalink