From 9d2cfd3917d87580f5b38c264452768cf5c08233 Mon Sep 17 00:00:00 2001 From: Sathya Gunasekaran Date: Wed, 5 Sep 2018 12:34:25 -0700 Subject: [PATCH] [class] Fix code coverage and add tests for public class fields Bug: v8:5367 Change-Id: Id3c2075e3c0a8f9b81a9c6b5f0578b6ecfa58001 Reviewed-on: https://chromium-review.googlesource.com/1205834 Reviewed-by: Georg Neis Reviewed-by: Jakob Gruber Commit-Queue: Sathya Gunasekaran Cr-Commit-Position: refs/heads/master@{#55687} --- src/parsing/parser-base.h | 16 +- test/mjsunit/code-coverage-class-fields.js | 199 +++++++++++++++++++++ 2 files changed, 208 insertions(+), 7 deletions(-) create mode 100644 test/mjsunit/code-coverage-class-fields.js diff --git a/src/parsing/parser-base.h b/src/parsing/parser-base.h index 8d8bbc3619..1f301c280d 100644 --- a/src/parsing/parser-base.h +++ b/src/parsing/parser-base.h @@ -1126,8 +1126,8 @@ class ParserBase { ClassLiteralChecker* checker, ClassInfo* class_info, IdentifierT* property_name, bool has_extends, bool* is_computed_name, ClassLiteralProperty::Kind* property_kind, bool* is_static, bool* ok); - ExpressionT ParseClassFieldInitializer(ClassInfo* class_info, bool is_static, - bool* ok); + ExpressionT ParseClassFieldInitializer(ClassInfo* class_info, int beg_pos, + bool is_static, bool* ok); ObjectLiteralPropertyT ParseObjectPropertyDefinition( ObjectLiteralChecker* checker, bool* is_computed_name, bool* is_rest_property, bool* ok); @@ -2319,7 +2319,8 @@ ParserBase::ParseClassPropertyDefinition( DCHECK_IMPLIES(name_token == Token::PRIVATE_NAME, allow_harmony_private_fields()); - int name_token_position = scanner()->peek_location().beg_pos; + int property_beg_pos = scanner()->peek_location().beg_pos; + int name_token_position = property_beg_pos; *name = impl()->NullIdentifier(); ExpressionT name_expression; if (name_token == Token::STATIC) { @@ -2384,8 +2385,9 @@ ParserBase::ParseClassPropertyDefinition( checker->CheckClassFieldName(*is_static, CHECK_OK_CUSTOM(NullLiteralProperty)); } - ExpressionT initializer = ParseClassFieldInitializer( - class_info, *is_static, CHECK_OK_CUSTOM(NullLiteralProperty)); + ExpressionT initializer = + ParseClassFieldInitializer(class_info, property_beg_pos, *is_static, + CHECK_OK_CUSTOM(NullLiteralProperty)); ExpectSemicolon(CHECK_OK_CUSTOM(NullLiteralProperty)); ClassLiteralPropertyT result = factory()->NewClassLiteralProperty( name_expression, initializer, *property_kind, *is_static, @@ -2486,7 +2488,7 @@ ParserBase::ParseClassPropertyDefinition( template typename ParserBase::ExpressionT -ParserBase::ParseClassFieldInitializer(ClassInfo* class_info, +ParserBase::ParseClassFieldInitializer(ClassInfo* class_info, int beg_pos, bool is_static, bool* ok) { DeclarationScope* initializer_scope = is_static ? class_info->static_fields_scope @@ -2496,7 +2498,7 @@ ParserBase::ParseClassFieldInitializer(ClassInfo* class_info, initializer_scope = NewFunctionScope(FunctionKind::kClassFieldsInitializerFunction); // TODO(gsathya): Make scopes be non contiguous. - initializer_scope->set_start_position(scanner()->location().end_pos); + initializer_scope->set_start_position(beg_pos); initializer_scope->SetLanguageMode(LanguageMode::kStrict); } diff --git a/test/mjsunit/code-coverage-class-fields.js b/test/mjsunit/code-coverage-class-fields.js new file mode 100644 index 0000000000..a91c25824f --- /dev/null +++ b/test/mjsunit/code-coverage-class-fields.js @@ -0,0 +1,199 @@ +// Copyright 2017 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. + +// Flags: --allow-natives-syntax --no-always-opt --harmony-public-fields --harmony-static-fields +// Files: test/mjsunit/code-coverage-utils.js + +%DebugToggleBlockCoverage(true); + +TestCoverage( +"class with no fields", +`class X { // 000 +}; // 050 +`, + [ + { start: 0, end: 98, count: 1 }, + { start: 0, end: 0, count: 0 }, + ] +); + +TestCoverage( +"class that's not created", +`class X { // 000 + x = function() { } // 050 +}; // 100 +`, + [ + { start: 0, end: 148, count: 1 }, + { start: 0, end: 0, count: 0 }, + { start: 51, end: 69, count: 0 }, + ] +); + +TestCoverage( +"class with field thats not called", +`class X { // 000 + x = function() { } // 050 +}; // 100 +let x = new X(); // 150 +`, + [ + { start: 0, end: 198, count: 1 }, + { start: 0, end: 0, count: 1 }, + { start: 51, end: 69, count: 1 }, + { start: 55, end: 69, count: 0 } + ] +); + +TestCoverage( +"class field", +`class X { // 000 + x = function() { } // 050 +}; // 100 +let x = new X(); // 150 +x.x(); // 200 +`, + [ + { start: 0, end: 248, count: 1 }, + { start: 0, end: 0, count: 1 }, + { start: 51, end: 69, count: 1 }, + { start: 55, end: 69, count: 1 } + ] +); + +TestCoverage( +"non contiguous class field", +`class X { // 000 + x = function() { } // 050 + foo() { } // 100 + y = function() {} // 150 +}; // 200 +let x = new X(); // 250 +x.x(); // 300 +x.y(); // 350 +`, + [ + { start: 0, end: 398, count: 1 }, + { start: 0, end: 0, count: 1 }, + { start: 51, end: 168, count: 1 }, + { start: 55, end: 69, count: 1 }, + { start: 101, end: 110, count: 0 }, + { start: 155, end: 168, count: 1 }, + ] +); + +TestCoverage( +"non contiguous class field thats called", +`class X { // 000 + x = function() { } // 050 + foo() { } // 100 + y = function() {} // 150 +}; // 200 +let x = new X(); // 250 +x.x(); // 300 +x.y(); // 350 +x.foo(); // 400 +`, + [ + { start: 0, end: 448, count: 1 }, + { start: 0, end: 0, count: 1 }, + { start: 51, end: 168, count: 1 }, + { start: 55, end: 69, count: 1 }, + { start: 101, end: 110, count: 1 }, + { start: 155, end: 168, count: 1 }, + ] +); + +TestCoverage( +"class with initializer iife", +`class X { // 000 + x = (function() { })() // 050 +}; // 100 +let x = new X(); // 150 +`, + [ + { start: 0, end: 198, count: 1 }, + { start: 0, end: 0, count: 1 }, + { start: 51, end: 73, count: 1 }, + { start: 56, end: 70, count: 1 } + ] +); + +TestCoverage( +"class with computed field", +` +function f() {}; // 000 +class X { // 050 + [f()] = (function() { })() // 100 +}; // 150 +let x = new X(); // 200 +`, + [ + { start: 0, end: 249, count: 1 }, + { start: 0, end: 15, count: 1 }, + { start: 50, end: 50, count: 1 }, + { start: 102, end: 128, count: 1 }, + { start: 111, end: 125, count: 1 } + ] +); + +TestCoverage( +"static class field that's not called", +`class X { // 000 + static x = function() { } // 050 +}; // 100 +`, + [ + { start: 0, end: 148, count: 1 }, + { start: 0, end: 0, count: 0 }, + { start: 51, end: 76, count: 1 }, + { start: 62, end: 76, count: 0 } + ] +); + +TestCoverage( +"static class field", +`class X { // 000 + static x = function() { } // 050 +}; // 100 +X.x(); // 150 +`, + [ + { start: 0, end: 198, count: 1 }, + { start: 0, end: 0, count: 0 }, + { start: 51, end: 76, count: 1 }, + { start: 62, end: 76, count: 1 } + ] +); + +TestCoverage( +"static class field with iife", +`class X { // 000 + static x = (function() { })() // 050 +}; // 100 +`, + [ + { start: 0, end: 148, count: 1 }, + { start: 0, end: 0, count: 0 }, + { start: 51, end: 80, count: 1 }, + { start: 63, end: 77, count: 1 } + ] +); + +TestCoverage( +"computed static class field", +` +function f() {} // 000 +class X { // 050 + static [f()] = (function() { })() // 100 +}; // 150 +`, + [ + { start: 0, end: 199, count: 1 }, + { start: 0, end: 15, count: 1 }, + { start: 50, end: 50, count: 0 }, + { start: 102, end: 135, count: 1 }, + { start: 118, end: 132, count: 1 } + ] +);