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.
501 // function. Includes regexp literals, and boilerplate for object
721 // Parse the function literal.
927 // function contains only assignments of this type.
938 // Bail out if function already has property assignment that are
954 // constant or a function argument was encountered.
1006 // name of one of the arguments to the function.
1019 // Assigned from function argument.
1093 if (peek() == Token::FUNCTION) {
1099 // Common language extension is to allow function declaration in place
1261 case Token::FUNCTION: {
1296 // If we are inside a function, a declaration of a variable
1298 // is always the function scope.
1300 // If a function scope exists, then we can statically declare this
1305 // to the calling function context.
1307 // Declare the variable in the function scope.
1360 // statements: the corresponding function (or const) variable must be in the
1361 // function scope and not a statement-local scope, e.g. as provided with a
1365 // function f() {}
1371 // // in this case this is not: 'var f; f = function () {};'
1372 // var f = function () {};
1389 // through the API's extension mechanism. A native function
1390 // declaration is resolved by looking up the function through a
1400 Expect(Token::FUNCTION, CHECK_OK);
1414 // Make sure that the function containing the native declaration
1420 // Compute the function template for the native function.
1425 // Instantiate the function and create a shared function info from it.
1435 // Copy the function data to the shared function info.
1440 // TODO(1240846): It's weird that native function declarations are
1453 // 'function' Identifier '(' FormalParameterListopt ')' '{' FunctionBody '}'
1454 Expect(Token::FUNCTION, CHECK_OK);
1463 // Even if we're not at the top-level of the global or a function
1464 // scope, we treat is as such and introduce the function with it's
1536 // The scope of a variable/const declared anywhere inside a function
1537 // is the entire function (ECMA-262, 3rd, 10.1.3, and 12.2). Thus we can
1538 // transform a source-level variable/const declaration into a (Function)
1571 // is declared (and set to 'undefined') upon entering the function within
1572 // which the variable or constant is declared. Only function variables have
1574 // entering the function).
1623 // Don't infer if it is "a = function(){...}();"-like expression.
1638 // by the declarations part of the function representing the
1666 // Note that the function does different things depending on
1690 // Note that the function does different things depending on
1708 // always at the function scope level. This is only relevant for
1710 // for constant lookups is always the function context, while it is
1884 // function. See ECMA-262, section 12.9, page 67.
2364 // If we assign a function literal to a property we pretenure the
2365 // literal so it can be added as a constant function property.
2372 // name if we're dealing with "a = function(){...}();"-like
2673 // function.
2750 // Parse the initial primary or function expression.
2752 if (peek() == Token::FUNCTION) {
2753 Expect(Token::FUNCTION, CHECK_OK);
2938 parenthesized_function_ = (peek() == Token::FUNCTION);
3428 // Mark object literals that contain function literals and pretenure the
3429 // literal so it can be added as a constant function property.
3523 // Function ::
3527 // The name associated with this function. If it's a function expression,
3528 // this is the actual function name, otherwise this is the name of the
3529 // variable declared and initialized with the function (expression). In
3530 // that case, we don't have a function name (it's empty).
3533 // The function name, if any.
3548 // Parse function body.
3595 // If we have a named function expression, we add a local variable
3596 // declaration to the body of the function with the name of the
3597 // function and let it refer to the function itself (closure).
3612 // Determine if the function will be lazily compiled. The mode can
3618 parenthesized_function_ = false; // The bit was set for this function only.
3730 const Runtime::Function* function = Runtime::FunctionForSymbol(name);
3733 if (function != NULL &&
3734 function->intrinsic_type == Runtime::RUNTIME &&
3735 function->function_id == Runtime::kIS_VAR) {
3738 // inline function %_IS_VAR(x) to eliminate this special case.
3749 if (function != NULL &&
3750 function->nargs != -1 &&
3751 function->nargs != args->length()) {
3758 return new(zone()) CallRuntime(name, function, args);
3892 // This function reads an identifier and determines whether or not it
5140 ASSERT(info->function() == NULL);
