Lines Matching defs:variable

34 //       When inserting a new variable via Declare(), we rely on the fact that
35 //       the handle location remains alive for the duration of that variable
63     // The variable has not been declared yet -> insert it.
65     Variable* variable =
68     p->value = variable;
207   // If the class variable is context-allocated and its index is
259     // object variable (we don't store it explicitly).
299   // Cache the catch variable, even though it's also available via the
301   // variable as first and only variable.
303   Variable* variable =
307   AllocateHeapSlot(variable);
611   // For each variable which is used as a function declaration in a sloppy
617     // If the variable wouldn't conflict with a lexical declaration
759   // Declare 'arguments' variable which exists in all non arrow functions.  Note
761   // variable allocation.
772     // Check if there's lexically declared variable named arguments to avoid
1060   // introduced during variable allocation, and VariableMode::kTemporary
1076   // function, which, for efficiency, we preparse without variable tracking.
1110   // Declare the variable in the declaration scope.
1117       // The proxy is bound to a lookup variable to force a dynamic declaration
1163   // same variable if it is declared several times. This is not a
1188   // Declare the variable in the declaration scope.
1233   // TODO(neis): Mark variable as maybe-assigned?
1312         // exception is the binding variable in catch scopes, which is handled
1351   // Module variables must be allocated before variable resolution
1595     // Module variables must be allocated before variable resolution
2094     // Try to find the variable in this scope.
2113     // We found a variable and we are done. (Even if there is an 'eval' in this
2114     // scope which introduces the same variable again, the resulting variable
2117     // For sloppy eval though, we skip dynamic variable to avoid resolving to a
2118     // variable when the variable and proxy are in the same eval execution. The
2119     // variable is not available on subsequent lazy executions of functions in
2168   // No binding has been found. Declare a variable on the global object.
2195   // The current scope is a with scope, so the variable binding can not be
2198   // scope, the associated variable has to be marked as potentially being
2250   // A variable binding may have been found in an outer scope, but the current
2251   // scope makes a sloppy 'eval' call, so the found variable may not be the
2255   // here (this excludes block and catch scopes), and variable lookups at
2292     // but the variable they shadow might need a hole check, which we want to do
2293     // if we decide that no shadowing variable was dynamically introoduced.
2312   // physically located after the initializer of the variable, and that the
2323   // The scope of the variable needs to be checked, in case the use is
2349   // Resolve the variable in all parsed scopes to force context allocation.
2393   // via an eval() call.  This is only possible if the variable has a
2513     // temporaries to make the local variable ordering stable when reparsing to
2745   // variable. Consider the case of a super.property usage in heritage position:
2807   // Restore variable allocation results for context-allocated variables in
3021         // If the variable being accessed is a static private method, we need to
3022         // save the class variable in the context to check that the receiver is
3033       // There's no outer private name scope so we are certain that the variable