Fix issue 1354: Bad function name inference.

src/func-name-inferrer.h

 // Copyright 2006-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 25 matching lines @@
 // Inference is performed in cases when an anonymous function is assigned
 // to a variable or a property (see test-func-name-inference.cc for examples.)
 //
 // The basic idea is that during parsing of LHSs of certain expressions
 // (assignments, declarations, object literals) we collect name strings,
 // and during parsing of the RHS, a function literal can be collected. After
 // parsing the RHS we can infer a name for function literals that do not have
 // a name.
 class FuncNameInferrer : public ZoneObject {
  public:
-  FuncNameInferrer()
-      : entries_stack_(10),
-        names_stack_(5),
-        funcs_to_infer_(4),
-        dot_(FACTORY->NewStringFromAscii(CStrVector("."))) {
-  }
+  FuncNameInferrer();
 
   // Returns whether we have entered name collection state.
   bool IsOpen() const { return !entries_stack_.is_empty(); }
 
   // Pushes an enclosing the name of enclosing function onto names stack.
   void PushEnclosingName(Handle<String> name);
 
   // Enters name collection state.
   void Enter() {
     entries_stack_.Add(names_stack_.length());
@@ skipping 12 matching lines @@
   }
 
   // Infers a function name and leaves names collection state.
   void Infer() {
     ASSERT(IsOpen());
     if (!funcs_to_infer_.is_empty()) {
       InferFunctionsNames();
     }
   }
 
   // Infers a function name and leaves names collection state.

[Vitaly Repeshko, 2011/06/22 13:21:30]

The comment should be fixed.

[mnaganov (inactive), 2011/06/22 20:21:08]

Done.

   void Leave() {
     ASSERT(IsOpen());
     names_stack_.Rewind(entries_stack_.RemoveLast());
   }
 
+  Handle<String> anonymous_function() { return anonymous_function_; }
+
+  static const char* const kAnonymousFunctionName;
+
  private:
+  enum NameType {
+    kEnclosingConstructorName,
+    kLiteralName,
+    kVariableName
+  };
+  struct Name {
+    Name(Handle<String> name, NameType type) : name(name), type(type) { }
+    Handle<String> name;
+    NameType type;
+  };
+
   // Constructs a full name in dotted notation from gathered names.
   Handle<String> MakeNameFromStack();
 
   // A helper function for MakeNameFromStack.
   Handle<String> MakeNameFromStackHelper(int pos, Handle<String> prev);
 
   // Performs name inferring for added functions.
   void InferFunctionsNames();
 
   ZoneList<int> entries_stack_;
-  ZoneList<Handle<String> > names_stack_;
+  ZoneList<Name> names_stack_;
   ZoneList<FunctionLiteral*> funcs_to_infer_;
   Handle<String> dot_;

[Vitaly Repeshko, 2011/06/22 13:21:30]

Function name inference is an integral part of the parser now. It's better to
move these two symbols to the global list in the heap instead of allocating them
as strings here. 

[mnaganov (inactive), 2011/06/22 20:21:08]

Done.

+  Handle<String> anonymous_function_;
 
   DISALLOW_COPY_AND_ASSIGN(FuncNameInferrer);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_FUNC_NAME_INFERRER_H_