Lines Matching refs:DECLARATION
1021 : FunctionLiteral::DECLARATION;
1209 Declaration* declaration =
1211 Declare(declaration, true, CHECK_OK);
1428 // Generate a separate declaration for each identifier.
1429 // TODO(ES6): once we implement destructuring, make that one declaration.
1451 Declaration* declaration =
1453 Declare(declaration, true, CHECK_OK);
1543 // ExportDeclaration* declaration =
1545 // scope_->AddDeclaration(declaration);
1669 // Common language extension is to allow function declaration in place
1707 // If we are inside a function, a declaration of a var/const variable is a
1717 void Parser::Declare(Declaration* declaration, bool resolve, bool* ok) {
1718 VariableProxy* proxy = declaration->proxy();
1721 VariableMode mode = declaration->mode();
1726 // variable and also set its mode. In any case, a Declaration node
1727 // will be added to the scope so that the declaration can be added
1738 // Declare the variable in the declaration scope.
1748 declaration->initialization(),
1764 // because the var declaration is hoisted to the function scope where 'x'
1775 "var_redeclaration", name, declaration->position());
1782 // We add a declaration node for every declaration. The compiler
1793 // WARNING: This will lead to multiple declaration nodes for the
1798 declaration_scope->AddDeclaration(declaration);
1810 // to a lookup variable to force a dynamic declaration using the
1815 declaration->initialization(), kNotAssigned,
1876 // declaration is resolved by looking up the function through a
1895 // Make sure that the function containing the native declaration
1905 Declaration* declaration =
1907 Declare(declaration, true, CHECK_OK);
1934 pos, FunctionLiteral::DECLARATION,
1946 Declaration* declaration =
1948 Declare(declaration, true, CHECK_OK);
1980 Declaration* declaration =
1982 Declare(declaration, true, CHECK_OK);
2071 // If the variable declaration declares exactly one non-const
2099 // bindings are created uninitialized by their declaration nodes and
2101 // immediately by their declaration nodes.
2163 // transform a source-level var/const declaration into a (Function)
2164 // Scope declaration, and rewrite the source-level initialization into an
2173 // Create new block with one expected declaration.
2191 // an initial value in the declaration (because they are initialized upon
2194 // If we have a const declaration, in an inner scope, the proxy is always
2199 // declaration.
2203 Declaration* declaration =
2205 Declare(declaration, mode != VAR, CHECK_OK);
2215 // declaration of the form:
2225 // declaration (e.g., if we are inside a 'with' statement or 'catch'
2229 // declaration of the form:
2271 // way. When the script containing the global variable declaration
2278 // *not* touched until the variable declaration statement is
2281 // Executing the variable declaration statement will always
2285 // declaration statement has been executed. This is important in
2376 // If there was a single non-const declaration, return it in the output
2437 // If we have an extension, we allow a native function declaration.
2438 // A native function declaration starts with "native function" with
3025 Declaration* declaration =
3027 Declare(declaration, true, CHECK_OK);
3028 inner_vars.Add(declaration->proxy()->var(), zone());
3147 // Parsed for-in loop w/ variable/const declaration.
3209 // Parsed for-in loop w/ let declaration.
3471 // their declaration is hoisted, but they still see the local scope. E.g.,
3486 // under which we compile is _not_ a declaration scope. This holds because
3488 // declaration scope and compiled relative to that.
3489 // - (2) is the case iff the current declaration scope is still the original
3491 // compiling a function in an inner declaration scope in the eval, e.g. a
3496 function_type == FunctionLiteral::DECLARATION &&
3589 // declaration to the body of the function with the name of the
3920 Declaration* decl = scope->CheckConflictingVarDeclarations();
