Rename the toplevel code generator from "Fast" to "Full". It was...

src/fast-codegen.h

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 17 matching lines @@
 #ifndef V8_FAST_CODEGEN_H_
 #define V8_FAST_CODEGEN_H_
 
 #include "v8.h"
 
 #include "ast.h"
 
 namespace v8 {
 namespace internal {
 
+class FullCodeGenSyntaxChecker: public AstVisitor {
+ public:
+  FullCodeGenSyntaxChecker() : has_supported_syntax_(true) {}
+
+  void Check(FunctionLiteral* fun);
+
+  bool has_supported_syntax() { return has_supported_syntax_; }
+
+ private:
+  void VisitDeclarations(ZoneList<Declaration*>* decls);
+  void VisitStatements(ZoneList<Statement*>* stmts);
+
+  // AST node visit functions.
+#define DECLARE_VISIT(type) virtual void Visit##type(type* node);
+  AST_NODE_LIST(DECLARE_VISIT)
+#undef DECLARE_VISIT
+
+  bool has_supported_syntax_;
+
+  DISALLOW_COPY_AND_ASSIGN(FullCodeGenSyntaxChecker);
+};
+
+
 // -----------------------------------------------------------------------------
-// Fast code generator.
+// Full code generator.
 
-class FastCodeGenerator: public AstVisitor {
+class FullCodeGenerator: public AstVisitor {
  public:
-  FastCodeGenerator(MacroAssembler* masm, Handle<Script> script, bool is_eval)
+  FullCodeGenerator(MacroAssembler* masm, Handle<Script> script, bool is_eval)
       : masm_(masm),
         function_(NULL),
         script_(script),
         is_eval_(is_eval),
         nesting_stack_(NULL),
         loop_depth_(0),
         location_(kStack),
         true_label_(NULL),
         false_label_(NULL) {
   }
 
   static Handle<Code> MakeCode(FunctionLiteral* fun,
                                Handle<Script> script,
                                bool is_eval);
 
   void Generate(FunctionLiteral* fun);
 
  private:
   class Breakable;
   class Iteration;
   class TryCatch;
   class TryFinally;
   class Finally;
   class ForIn;
 
   class NestedStatement BASE_EMBEDDED {
    public:
-    explicit NestedStatement(FastCodeGenerator* codegen) : codegen_(codegen) {
+    explicit NestedStatement(FullCodeGenerator* codegen) : codegen_(codegen) {
       // Link into codegen's nesting stack.
       previous_ = codegen->nesting_stack_;
       codegen->nesting_stack_ = this;
     }
     virtual ~NestedStatement() {
       // Unlink from codegen's nesting stack.
       ASSERT_EQ(this, codegen_->nesting_stack_);
       codegen_->nesting_stack_ = previous_;
     }
 
@@ skipping 17 matching lines @@
     // contains the value in case of a return).
     virtual int Exit(int stack_depth) {
       // Default implementation for the case where there is
       // nothing to clean up.
       return stack_depth;
     }
     NestedStatement* outer() { return previous_; }
    protected:
     MacroAssembler* masm() { return codegen_->masm(); }
    private:
-    FastCodeGenerator* codegen_;
+    FullCodeGenerator* codegen_;
     NestedStatement* previous_;
     DISALLOW_COPY_AND_ASSIGN(NestedStatement);
   };
 
   class Breakable : public NestedStatement {
    public:
-    Breakable(FastCodeGenerator* codegen,
+    Breakable(FullCodeGenerator* codegen,
               BreakableStatement* break_target)
         : NestedStatement(codegen),
           target_(break_target) {}
     virtual ~Breakable() {}
     virtual Breakable* AsBreakable() { return this; }
     virtual bool IsBreakTarget(Statement* statement) {
       return target_ == statement;
     }
     BreakableStatement* statement() { return target_; }
     Label* break_target() { return &break_target_label_; }
    private:
     BreakableStatement* target_;
     Label break_target_label_;
     DISALLOW_COPY_AND_ASSIGN(Breakable);
   };
 
   class Iteration : public Breakable {
    public:
-    Iteration(FastCodeGenerator* codegen,
+    Iteration(FullCodeGenerator* codegen,
               IterationStatement* iteration_statement)
         : Breakable(codegen, iteration_statement) {}
     virtual ~Iteration() {}
     virtual Iteration* AsIteration() { return this; }
     virtual bool IsContinueTarget(Statement* statement) {
       return this->statement() == statement;
     }
     Label* continue_target() { return &continue_target_label_; }
    private:
     Label continue_target_label_;
     DISALLOW_COPY_AND_ASSIGN(Iteration);
   };
 
   // The environment inside the try block of a try/catch statement.
   class TryCatch : public NestedStatement {
    public:
-    explicit TryCatch(FastCodeGenerator* codegen, Label* catch_entry)
+    explicit TryCatch(FullCodeGenerator* codegen, Label* catch_entry)
         : NestedStatement(codegen), catch_entry_(catch_entry) { }
     virtual ~TryCatch() {}
     virtual TryCatch* AsTryCatch() { return this; }
     Label* catch_entry() { return catch_entry_; }
     virtual int Exit(int stack_depth);
    private:
     Label* catch_entry_;
     DISALLOW_COPY_AND_ASSIGN(TryCatch);
   };
 
   // The environment inside the try block of a try/finally statement.
   class TryFinally : public NestedStatement {
    public:
-    explicit TryFinally(FastCodeGenerator* codegen, Label* finally_entry)
+    explicit TryFinally(FullCodeGenerator* codegen, Label* finally_entry)
         : NestedStatement(codegen), finally_entry_(finally_entry) { }
     virtual ~TryFinally() {}
     virtual TryFinally* AsTryFinally() { return this; }
     Label* finally_entry() { return finally_entry_; }
     virtual int Exit(int stack_depth);
    private:
     Label* finally_entry_;
     DISALLOW_COPY_AND_ASSIGN(TryFinally);
   };
 
   // A FinallyEnvironment represents being inside a finally block.
   // Abnormal termination of the finally block needs to clean up
   // the block's parameters from the stack.
   class Finally : public NestedStatement {
    public:
-    explicit Finally(FastCodeGenerator* codegen) : NestedStatement(codegen) { }
+    explicit Finally(FullCodeGenerator* codegen) : NestedStatement(codegen) { }
     virtual ~Finally() {}
     virtual Finally* AsFinally() { return this; }
     virtual int Exit(int stack_depth) {
       return stack_depth + kFinallyStackElementCount;
     }
    private:
     // Number of extra stack slots occupied during a finally block.
     static const int kFinallyStackElementCount = 2;
     DISALLOW_COPY_AND_ASSIGN(Finally);
   };
 
   // A ForInEnvironment represents being inside a for-in loop.
   // Abnormal termination of the for-in block needs to clean up
   // the block's temporary storage from the stack.
   class ForIn : public Iteration {
    public:
-    ForIn(FastCodeGenerator* codegen,
+    ForIn(FullCodeGenerator* codegen,
           ForInStatement* statement)
         : Iteration(codegen, statement) { }
     virtual ~ForIn() {}
     virtual ForIn* AsForIn() { return this; }
     virtual int Exit(int stack_depth) {
       return stack_depth + kForInStackElementCount;
     }
    private:
     // TODO(lrn): Check that this value is correct when implementing
     // for-in.
@@ skipping 193 matching lines @@
   NestedStatement* nesting_stack_;
   int loop_depth_;
 
   Expression::Context context_;
   Location location_;
   Label* true_label_;
   Label* false_label_;
 
   friend class NestedStatement;
 
-  DISALLOW_COPY_AND_ASSIGN(FastCodeGenerator);
+  DISALLOW_COPY_AND_ASSIGN(FullCodeGenerator);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_FAST_CODEGEN_H_