Lines Matching refs:Function
342 // Check that the space allocated for function entries is sane.
351 // Check that the total size has room for header and function entries.
465 // pop. They are also used to hold the parser's per-function and per-block
706 // Parse the function literal.
942 // function contains only assignments of this type.
954 // Bail out if function already has property assignment that are
970 // constant or a function argument was encountered.
1020 // name of one of the arguments to the function.
1033 // Assigned from function argument.
1209 case Token::FUNCTION:
1508 case Token::FUNCTION:
1560 case Token::FUNCTION:
1669 case Token::FUNCTION: {
1675 // Common language extension is to allow function declaration in place
1702 // If we are inside a function, a declaration of a var/const variable is a
1703 // truly local variable, and the scope of the variable is always the function
1719 // If a function scope exists, then we can statically declare this
1724 // to the calling function context.
1734 // Declare the variable in the function scope.
1744 // functions. The function CheckNonConflictingScope checks for conflicting
1748 // function () { let x; { var x; } }
1750 // because the var declaration is hoisted to the function scope where 'x'
1813 // DeclareContextSlot runtime function.
1827 // statements: the corresponding function (or const) variable must be in the
1828 // function scope and not a statement-local scope, e.g. as provided with a
1832 // function f() {}
1838 // // in this case this is not: 'var f; f = function () {};'
1839 // var f = function () {};
1877 // through the API's extension mechanism. A native function
1878 // declaration is resolved by looking up the function through a
1881 Expect(Token::FUNCTION, CHECK_OK);
1895 // Make sure that the function containing the native declaration
1901 // Compute the function template for the native function.
1906 // Instantiate the function and create a shared function info from it.
1916 // Copy the function data to the shared function info.
1921 // TODO(1240846): It's weird that native function declarations are
1938 // 'function' Identifier '(' FormalParameterListopt ')' '{' FunctionBody '}'
1939 Expect(Token::FUNCTION, CHECK_OK);
1949 // Even if we're not at the top-level of the global or a function
1950 // scope, we treat is as such and introduce the function with it's
2139 // The scope of a var/const declared variable anywhere inside a function
2140 // is the entire function (ECMA-262, 3rd, 10.1.3, and 12.2). Thus we can
2141 // transform a source-level var/const declaration into a (Function)
2174 // is declared (and set to 'undefined') upon entering the function within
2175 // which the variable or constant is declared. Only function variables have
2177 // entering the function).
2233 // Don't infer if it is "a = function(){...}();"-like expression.
2259 // by the declarations part of the function representing the
2286 // Note that the function does different things depending on
2309 // Note that the function does different things depending on
2320 // is always at the function scope level. This is only relevant for
2322 // constant lookups is always the function context, while it is the top
2410 // If we have an extension, we allow a native function declaration.
2411 // A native function declaration starts with "native function" with
2414 peek() == Token::FUNCTION &&
2550 // function. See ECMA-262, section 12.9, page 67.
3076 // If we assign a function literal to a property we pretenure the
3077 // literal so it can be added as a constant function property.
3084 // name if we're dealing with "a = function(){...}();"-like
3377 // expressions of the form function(){...}() for which call position
3379 // with positions recorded for function literal and confuse debugger.
3465 // Parse the initial primary or function expression.
3467 if (peek() == Token::FUNCTION) {
3468 Expect(Token::FUNCTION, CHECK_OK);
3676 parenthesized_function_ = (peek() == Token::FUNCTION);
4190 // Mark top-level object literals that contain function literals and
4191 // pretenure the literal so it can be added as a constant function
4364 // For function entries.
4379 // Function ::
4383 // handle as the function name. Remember if we were passed a non-empty
4384 // handle to decide whether to invoke function name inference.
4387 // We want a non-null handle as the function name.
4393 // Function declarations are function scoped in normal mode, so they are
4408 // Parse function body.
4454 // If we have a named function expression, we add a local variable
4455 // declaration to the body of the function with the name of the
4456 // function and let it refer to the function itself (closure).
4474 // Determine whether the function will be lazily compiled.
4479 // - The function mustn't be a function expression with an open parenthesis
4480 // before; we consider that a hint that the function will be called
4484 // function itself.
4489 parenthesized_function_ = false; // The bit was set for this function only.
4495 // If we have pre_data_, we use it to skip parsing the function body.
4497 // lazy function.
4520 // With no preparser data, we partially parse the function, without
4522 // function.
4690 const Runtime::Function* function = Runtime::FunctionForSymbol(name);
4693 if (function != NULL &&
4694 function->intrinsic_type == Runtime::RUNTIME &&
4695 function->function_id == Runtime::kIS_VAR) {
4698 // inline function %_IS_VAR(x) to eliminate this special case.
4709 if (function != NULL &&
4710 function->nargs != -1 &&
4711 function->nargs != args->length()) {
4718 return factory()->NewCallRuntime(name, function, args);
4896 // This function reads an identifier name and determines whether or not it
5979 ASSERT(info->function() == NULL);
