harmony-classes: Fix some issues with syntactic restriction on super(...).

src/ast-this-access-visitor.cc

 // Copyright 2014 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 "src/ast-this-access-visitor.h"
 #include "src/parser.h"
 
 namespace v8 {
 namespace internal {
 
 typedef class AstThisAccessVisitor ATAV;  // for code shortitude.
 
 ATAV::AstThisAccessVisitor(Zone* zone) : uses_this_(false) {
   InitializeAstVisitor(zone);
 }
 
 
 void ATAV::VisitVariableProxy(VariableProxy* proxy) {
   if (proxy->is_this()) {
     uses_this_ = true;
   }
 }
 
 
+void ATAV::VisitSuperReference(SuperReference* leaf) {
+  // disallow super.method() and super(...).
+  uses_this_ = true;
+}
+
+
+void ATAV::VisitCallNew(CallNew* e) {
+  // new super(..) does not use 'this'.
+  if (!e->expression()->IsSuperReference()) {
+    Visit(e->expression());
+  }
+  VisitExpressions(e->arguments());
+}
+
+
 // ---------------------------------------------------------------------------
 // -- Leaf nodes -------------------------------------------------------------
 // ---------------------------------------------------------------------------
 
 void ATAV::VisitVariableDeclaration(VariableDeclaration* leaf) {}
 void ATAV::VisitFunctionDeclaration(FunctionDeclaration* leaf) {}
 void ATAV::VisitModuleDeclaration(ModuleDeclaration* leaf) {}
 void ATAV::VisitImportDeclaration(ImportDeclaration* leaf) {}
 void ATAV::VisitExportDeclaration(ExportDeclaration* leaf) {}
 void ATAV::VisitModuleVariable(ModuleVariable* leaf) {}
 void ATAV::VisitModulePath(ModulePath* leaf) {}
 void ATAV::VisitModuleUrl(ModuleUrl* leaf) {}
 void ATAV::VisitEmptyStatement(EmptyStatement* leaf) {}
 void ATAV::VisitContinueStatement(ContinueStatement* leaf) {}
 void ATAV::VisitBreakStatement(BreakStatement* leaf) {}
 void ATAV::VisitDebuggerStatement(DebuggerStatement* leaf) {}
 void ATAV::VisitFunctionLiteral(FunctionLiteral* leaf) {}
 void ATAV::VisitNativeFunctionLiteral(NativeFunctionLiteral* leaf) {}
 void ATAV::VisitLiteral(Literal* leaf) {}
 void ATAV::VisitRegExpLiteral(RegExpLiteral* leaf) {}
 void ATAV::VisitThisFunction(ThisFunction* leaf) {}
-void ATAV::VisitSuperReference(SuperReference* leaf) {}
-
 
 // ---------------------------------------------------------------------------
 // -- Pass-through nodes------------------------------------------------------
 // ---------------------------------------------------------------------------
 void ATAV::VisitModuleLiteral(ModuleLiteral* e) { Visit(e->body()); }
 
 
 void ATAV::VisitBlock(Block* stmt) { VisitStatements(stmt->statements()); }
 
 
@@ skipping 30 matching lines @@
 
 
 void ATAV::VisitTryFinallyStatement(TryFinallyStatement* stmt) {
   Visit(stmt->try_block());
   Visit(stmt->finally_block());
 }
 
 
 void ATAV::VisitClassLiteral(ClassLiteral* e) {
   VisitIfNotNull(e->extends());
-  VisitIfNotNull(e->constructor());
+  Visit(e->constructor());
   ZoneList<ObjectLiteralProperty*>* properties = e->properties();
   for (int i = 0; i < properties->length(); i++) {
     Visit(properties->at(i)->value());
   }
 }
 
 
 void ATAV::VisitConditional(Conditional* e) {
   Visit(e->condition());
   Visit(e->then_expression());
@@ skipping 26 matching lines @@
   Visit(e->key());
 }
 
 
 void ATAV::VisitCall(Call* e) {
   Visit(e->expression());
   VisitExpressions(e->arguments());
 }
 
 
-void ATAV::VisitCallNew(CallNew* e) {
-  Visit(e->expression());
-  VisitExpressions(e->arguments());
-}
-
-
 void ATAV::VisitCallRuntime(CallRuntime* e) {
   VisitExpressions(e->arguments());
 }
 
 
 void ATAV::VisitUnaryOperation(UnaryOperation* e) { Visit(e->expression()); }
 
 
 void ATAV::VisitBinaryOperation(BinaryOperation* e) {
   Visit(e->left());
@@ skipping 62 matching lines @@
   Visit(stmt->value());
 }
 
 
 void ATAV::VisitCountOperation(CountOperation* e) {
   Expression* l = e->expression();
   Visit(l);
 }
 }
 }  // namespace v8::internal