Extract ParseInfo from CompilationInfo.

src/globals.h

 // Copyright 2012 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.
 
 #ifndef V8_GLOBALS_H_
 #define V8_GLOBALS_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 434 matching lines @@
   VISIT_ALL,
   VISIT_ALL_IN_SCAVENGE,
   VISIT_ALL_IN_SWEEP_NEWSPACE,
   VISIT_ONLY_STRONG
 };
 
 // Flag indicating whether code is built into the VM (one of the natives files).
 enum NativesFlag { NOT_NATIVES_CODE, NATIVES_CODE };
 
 
+// ParseRestriction is used to restrict the set of valid statements in a
+// unit of compilation.  Restriction violations cause a syntax error.
+enum ParseRestriction {

[rossberg, 2015/03/04 10:25:12]

I don't think this belongs into global.h - it encodes a choice of start symbol
for parsing. In that sense, it has a similar role to flags like
parse_info->is_module(), and should probably be handled analogously. I.e., just
kill the enum and have a is_function flag in parse info. (And later we should
probably unify these flags into one grammar_entry kind of value.)

Short of that, can you at least move it to parser.h?

[titzer, 2015/03/05 20:18:30]

Michi argued strongly to keep the enum.

I initially tried to move it to parser.h, but then you end up with a cycle
between compiler.h and parser.h. Actually this cycle already exists and it needs
to be broken carefully to reduce the over-inclusion of compiler.h. Couldn't
figure out how to do that yet.

[Michael Starzinger, 2015/03/05 20:56:55]

I argued strongly for "not turning it into a boolean", correct. I would be fine
with the parser just reporting whether it consumed exactly one single function
literal or not, and then the caller checking that result. That would be fine
with me. FYI, the caller is all the way up in Runtime_CompileString.

+  NO_PARSE_RESTRICTION,         // All expressions are allowed.
+  ONLY_SINGLE_FUNCTION_LITERAL  // Only a single FunctionLiteral expression.
+};
+
 // A CodeDesc describes a buffer holding instructions and relocation
 // information. The instructions start at the beginning of the buffer
 // and grow forward, the relocation information starts at the end of
 // the buffer and grows backward.
 //
 //  |<--------------- buffer_size ---------------->|
 //  |<-- instr_size -->|        |<-- reloc_size -->|
 //  +==================+========+==================+
 //  |   instructions   |  free  |    reloc info    |
 //  +==================+========+==================+
@@ skipping 433 matching lines @@
   DCHECK(IsValidFunctionKind(kind));
   return kind &
          (FunctionKind::kBaseConstructor | FunctionKind::kSubclassConstructor |
           FunctionKind::kDefaultConstructor);
 }
 } }  // namespace v8::internal
 
 namespace i = v8::internal;
 
 #endif  // V8_GLOBALS_H_