compiler: Rename _env to _variableEnvironment

More in keeping with the spec's terminology, and allows us to introduce
a LexicalEnvironment for ES6.

Change-Id: I1d98387a0ad6372317cf1036f814ac0c6063c1bf
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>

3 files changed, 71 insertions, 71 deletions

diff --git a/src/qml/compiler/qqmlirbuilder.cpp b/src/qml/compiler/qqmlirbuilder.cpp
index 8a7507c92e..030f485504 100644
--- a/src/qml/compiler/qqmlirbuilder.cpp
+++ b/src/qml/compiler/qqmlirbuilder.cpp
@@ -1605,7 +1605,7 @@ QVector<int> JSCodeGen::generateJSCodeForFunctionsAndBindings(const QList<Compil
     scan.leaveEnvironment();
     scan.leaveEnvironment();
 
-    _env = 0;
+    _variableEnvironment = 0;
     _function = _module->functions.at(defineFunction(QStringLiteral("context scope"), qmlRoot, 0, 0));
 
     for (int i = 0; i < functions.count(); ++i) {
diff --git a/src/qml/compiler/qv4codegen.cpp b/src/qml/compiler/qv4codegen.cpp
index 53cbc3c5a0..5e351611f5 100644
--- a/src/qml/compiler/qv4codegen.cpp
+++ b/src/qml/compiler/qv4codegen.cpp
@@ -76,7 +76,7 @@ static inline void setLocation(IR::Stmt *s, const SourceLocation &loc)
 Codegen::ScanFunctions::ScanFunctions(Codegen *cg, const QString &sourceCode, CompilationMode defaultProgramMode)
     : _cg(cg)
     , _sourceCode(sourceCode)
-    , _env(0)
+    , _variableEnvironment(0)
     , _allowFuncDecls(true)
     , defaultProgramMode(defaultProgramMode)
 {
@@ -90,17 +90,17 @@ void Codegen::ScanFunctions::operator()(Node *node)
 
 void Codegen::ScanFunctions::enterEnvironment(Node *node, CompilationMode compilationMode)
 {
-    Environment *e = _cg->newEnvironment(node, _env, compilationMode);
+    Environment *e = _cg->newEnvironment(node, _variableEnvironment, compilationMode);
     if (!e->isStrict)
         e->isStrict = _cg->_strictMode;
     _envStack.append(e);
-    _env = e;
+    _variableEnvironment = e;
 }
 
 void Codegen::ScanFunctions::leaveEnvironment()
 {
     _envStack.pop();
-    _env = _envStack.isEmpty() ? 0 : _envStack.top();
+    _variableEnvironment = _envStack.isEmpty() ? 0 : _envStack.top();
 }
 
 void Codegen::ScanFunctions::checkDirectivePrologue(SourceElements *ast)
@@ -116,7 +116,7 @@ void Codegen::ScanFunctions::checkDirectivePrologue(SourceElements *ast)
                         continue;
                     QStringRef str = _sourceCode.midRef(strLit->literalToken.offset + 1, strLit->literalToken.length - 2);
                     if (str == QLatin1String("use strict")) {
-                        _env->isStrict = true;
+                        _variableEnvironment->isStrict = true;
                     } else {
                         // TODO: give a warning.
                     }
@@ -131,7 +131,7 @@ void Codegen::ScanFunctions::checkDirectivePrologue(SourceElements *ast)
 
 void Codegen::ScanFunctions::checkName(const QStringRef &name, const SourceLocation &loc)
 {
-    if (_env->isStrict) {
+    if (_variableEnvironment->isStrict) {
         if (name == QLatin1String("implements")
                 || name == QLatin1String("interface")
                 || name == QLatin1String("let")
@@ -149,7 +149,7 @@ void Codegen::ScanFunctions::checkForArguments(AST::FormalParameterList *paramet
 {
     while (parameters) {
         if (parameters->name == QLatin1String("arguments"))
-            _env->usesArgumentsObject = Environment::ArgumentsObjectNotUsed;
+            _variableEnvironment->usesArgumentsObject = Environment::ArgumentsObjectNotUsed;
         parameters = parameters->next;
     }
 }
@@ -168,19 +168,19 @@ void Codegen::ScanFunctions::endVisit(Program *)
 
 bool Codegen::ScanFunctions::visit(CallExpression *ast)
 {
-    if (! _env->hasDirectEval) {
+    if (! _variableEnvironment->hasDirectEval) {
         if (IdentifierExpression *id = cast<IdentifierExpression *>(ast->base)) {
             if (id->name == QLatin1String("eval")) {
-                if (_env->usesArgumentsObject == Environment::ArgumentsObjectUnknown)
-                    _env->usesArgumentsObject = Environment::ArgumentsObjectUsed;
-                _env->hasDirectEval = true;
+                if (_variableEnvironment->usesArgumentsObject == Environment::ArgumentsObjectUnknown)
+                    _variableEnvironment->usesArgumentsObject = Environment::ArgumentsObjectUsed;
+                _variableEnvironment->hasDirectEval = true;
             }
         }
     }
     int argc = 0;
     for (ArgumentList *it = ast->arguments; it; it = it->next)
         ++argc;
-    _env->maxNumberOfArguments = qMax(_env->maxNumberOfArguments, argc);
+    _variableEnvironment->maxNumberOfArguments = qMax(_variableEnvironment->maxNumberOfArguments, argc);
     return true;
 }
 
@@ -189,7 +189,7 @@ bool Codegen::ScanFunctions::visit(NewMemberExpression *ast)
     int argc = 0;
     for (ArgumentList *it = ast->arguments; it; it = it->next)
         ++argc;
-    _env->maxNumberOfArguments = qMax(_env->maxNumberOfArguments, argc);
+    _variableEnvironment->maxNumberOfArguments = qMax(_variableEnvironment->maxNumberOfArguments, argc);
     return true;
 }
 
@@ -205,38 +205,38 @@ bool Codegen::ScanFunctions::visit(ArrayLiteral *ast)
         for (Elision *elision = ast->elision->next; elision; elision = elision->next)
             ++index;
     }
-    _env->maxNumberOfArguments = qMax(_env->maxNumberOfArguments, index);
+    _variableEnvironment->maxNumberOfArguments = qMax(_variableEnvironment->maxNumberOfArguments, index);
     return true;
 }
 
 bool Codegen::ScanFunctions::visit(VariableDeclaration *ast)
 {
-    if (_env->isStrict && (ast->name == QLatin1String("eval") || ast->name == QLatin1String("arguments")))
+    if (_variableEnvironment->isStrict && (ast->name == QLatin1String("eval") || ast->name == QLatin1String("arguments")))
         _cg->throwSyntaxError(ast->identifierToken, QStringLiteral("Variable name may not be eval or arguments in strict mode"));
     checkName(ast->name, ast->identifierToken);
     if (ast->name == QLatin1String("arguments"))
-        _env->usesArgumentsObject = Environment::ArgumentsObjectNotUsed;
+        _variableEnvironment->usesArgumentsObject = Environment::ArgumentsObjectNotUsed;
     if (ast->readOnly && !ast->expression) {
         _cg->throwSyntaxError(ast->identifierToken, QStringLiteral("Missing initializer in const declaration"));
         return false;
     }
     QString name = ast->name.toString();
     const Environment::Member *m = 0;
-    if (_env->memberInfo(name, &m)) {
+    if (_variableEnvironment->memberInfo(name, &m)) {
         if (m->isConstant || ast->readOnly) {
             _cg->throwSyntaxError(ast->identifierToken, QStringLiteral("Identifier %1 has already been declared").arg(name));
             return false;
         }
     }
-    _env->enter(ast->name.toString(), ast->expression ? Environment::VariableDefinition : Environment::VariableDeclaration, ast->readOnly);
+    _variableEnvironment->enter(ast->name.toString(), ast->expression ? Environment::VariableDefinition : Environment::VariableDeclaration, ast->readOnly);
     return true;
 }
 
 bool Codegen::ScanFunctions::visit(IdentifierExpression *ast)
 {
     checkName(ast->name, ast->identifierToken);
-    if (_env->usesArgumentsObject == Environment::ArgumentsObjectUnknown && ast->name == QLatin1String("arguments"))
-        _env->usesArgumentsObject = Environment::ArgumentsObjectUsed;
+    if (_variableEnvironment->usesArgumentsObject == Environment::ArgumentsObjectUnknown && ast->name == QLatin1String("arguments"))
+        _variableEnvironment->usesArgumentsObject = Environment::ArgumentsObjectUsed;
     return true;
 }
 
@@ -268,7 +268,7 @@ bool Codegen::ScanFunctions::visit(FunctionExpression *ast)
 
 void Codegen::ScanFunctions::enterFunction(FunctionExpression *ast, bool enterName, bool isExpression)
 {
-    if (_env->isStrict && (ast->name == QLatin1String("eval") || ast->name == QLatin1String("arguments")))
+    if (_variableEnvironment->isStrict && (ast->name == QLatin1String("eval") || ast->name == QLatin1String("arguments")))
         _cg->throwSyntaxError(ast->identifierToken, QStringLiteral("Function name may not be eval or arguments in strict mode"));
     enterFunction(ast, ast->name.toString(), ast->formals, ast->body, enterName ? ast : 0, isExpression);
 }
@@ -289,7 +289,7 @@ bool Codegen::ScanFunctions::visit(ObjectLiteral *ast)
         if (AST::cast<AST::PropertyGetterSetter *>(it->assignment))
             ++argc;
     }
-    _env->maxNumberOfArguments = qMax(_env->maxNumberOfArguments, argc);
+    _variableEnvironment->maxNumberOfArguments = qMax(_variableEnvironment->maxNumberOfArguments, argc);
 
     TemporaryBoolAssignment allowFuncDecls(_allowFuncDecls, true);
     Node::accept(ast->properties, this);
@@ -321,7 +321,7 @@ void Codegen::ScanFunctions::endVisit(FunctionDeclaration *)
 
 bool Codegen::ScanFunctions::visit(WithStatement *ast)
 {
-    if (_env->isStrict) {
+    if (_variableEnvironment->isStrict) {
         _cg->throwSyntaxError(ast->withToken, QStringLiteral("'with' statement is not allowed in strict mode"));
         return false;
     }
@@ -331,7 +331,7 @@ bool Codegen::ScanFunctions::visit(WithStatement *ast)
 
 bool Codegen::ScanFunctions::visit(DoWhileStatement *ast) {
     {
-        TemporaryBoolAssignment allowFuncDecls(_allowFuncDecls, !_env->isStrict);
+        TemporaryBoolAssignment allowFuncDecls(_allowFuncDecls, !_variableEnvironment->isStrict);
         Node::accept(ast->statement, this);
     }
     Node::accept(ast->expression, this);
@@ -343,7 +343,7 @@ bool Codegen::ScanFunctions::visit(ForStatement *ast) {
     Node::accept(ast->condition, this);
     Node::accept(ast->expression, this);
 
-    TemporaryBoolAssignment allowFuncDecls(_allowFuncDecls, !_env->isStrict);
+    TemporaryBoolAssignment allowFuncDecls(_allowFuncDecls, !_variableEnvironment->isStrict);
     Node::accept(ast->statement, this);
 
     return false;
@@ -354,7 +354,7 @@ bool Codegen::ScanFunctions::visit(LocalForStatement *ast) {
     Node::accept(ast->condition, this);
     Node::accept(ast->expression, this);
 
-    TemporaryBoolAssignment allowFuncDecls(_allowFuncDecls, !_env->isStrict);
+    TemporaryBoolAssignment allowFuncDecls(_allowFuncDecls, !_variableEnvironment->isStrict);
     Node::accept(ast->statement, this);
 
     return false;
@@ -364,7 +364,7 @@ bool Codegen::ScanFunctions::visit(ForEachStatement *ast) {
     Node::accept(ast->initialiser, this);
     Node::accept(ast->expression, this);
 
-    TemporaryBoolAssignment allowFuncDecls(_allowFuncDecls, !_env->isStrict);
+    TemporaryBoolAssignment allowFuncDecls(_allowFuncDecls, !_variableEnvironment->isStrict);
     Node::accept(ast->statement, this);
 
     return false;
@@ -374,7 +374,7 @@ bool Codegen::ScanFunctions::visit(LocalForEachStatement *ast) {
     Node::accept(ast->declaration, this);
     Node::accept(ast->expression, this);
 
-    TemporaryBoolAssignment allowFuncDecls(_allowFuncDecls, !_env->isStrict);
+    TemporaryBoolAssignment allowFuncDecls(_allowFuncDecls, !_variableEnvironment->isStrict);
     Node::accept(ast->statement, this);
 
     return false;
@@ -382,12 +382,12 @@ bool Codegen::ScanFunctions::visit(LocalForEachStatement *ast) {
 
 bool Codegen::ScanFunctions::visit(ThisExpression *)
 {
-    _env->usesThis = true;
+    _variableEnvironment->usesThis = true;
     return false;
 }
 
 bool Codegen::ScanFunctions::visit(Block *ast) {
-    TemporaryBoolAssignment allowFuncDecls(_allowFuncDecls, _env->isStrict ? false : _allowFuncDecls);
+    TemporaryBoolAssignment allowFuncDecls(_allowFuncDecls, _variableEnvironment->isStrict ? false : _allowFuncDecls);
     Node::accept(ast->statements, this);
     return false;
 }
@@ -395,26 +395,26 @@ bool Codegen::ScanFunctions::visit(Block *ast) {
 void Codegen::ScanFunctions::enterFunction(Node *ast, const QString &name, FormalParameterList *formals, FunctionBody *body, FunctionExpression *expr, bool isExpression)
 {
     bool wasStrict = false;
-    if (_env) {
-        _env->hasNestedFunctions = true;
+    if (_variableEnvironment) {
+        _variableEnvironment->hasNestedFunctions = true;
         // The identifier of a function expression cannot be referenced from the enclosing environment.
         if (expr)
-            _env->enter(name, Environment::FunctionDefinition, false /* readonly */, expr);
+            _variableEnvironment->enter(name, Environment::FunctionDefinition, false /* readonly */, expr);
         if (name == QLatin1String("arguments"))
-            _env->usesArgumentsObject = Environment::ArgumentsObjectNotUsed;
-        wasStrict = _env->isStrict;
+            _variableEnvironment->usesArgumentsObject = Environment::ArgumentsObjectNotUsed;
+        wasStrict = _variableEnvironment->isStrict;
     }
 
     enterEnvironment(ast, FunctionCode);
     checkForArguments(formals);
 
-    _env->isNamedFunctionExpression = isExpression && !name.isEmpty();
-    _env->formals = formals;
+    _variableEnvironment->isNamedFunctionExpression = isExpression && !name.isEmpty();
+    _variableEnvironment->formals = formals;
 
     if (body)
         checkDirectivePrologue(body->elements);
 
-    if (wasStrict || _env->isStrict) {
+    if (wasStrict || _variableEnvironment->isStrict) {
         QStringList args;
         for (FormalParameterList *it = formals; it; it = it->next) {
             QString arg = it->name.toString();
@@ -438,7 +438,7 @@ Codegen::Codegen(bool strict)
     , _block(0)
     , _exitBlock(0)
     , _returnAddress(0)
-    , _env(0)
+    , _variableEnvironment(0)
     , _loop(0)
     , _labelledStatement(0)
     , _scopeAndFinally(0)
@@ -458,7 +458,7 @@ void Codegen::generateFromProgram(const QString &fileName,
     Q_ASSERT(node);
 
     _module = module;
-    _env = 0;
+    _variableEnvironment = 0;
 
     _module->setFileName(fileName);
 
@@ -477,7 +477,7 @@ void Codegen::generateFromFunctionExpression(const QString &fileName,
 {
     _module = module;
     _module->setFileName(fileName);
-    _env = 0;
+    _variableEnvironment = 0;
 
     ScanFunctions scan(this, sourceCode, GlobalCode);
     // fake a global environment
@@ -494,14 +494,14 @@ void Codegen::generateFromFunctionExpression(const QString &fileName,
 
 void Codegen::enterEnvironment(Node *node)
 {
-    _env = _envMap.value(node);
-    Q_ASSERT(_env);
+    _variableEnvironment = _envMap.value(node);
+    Q_ASSERT(_variableEnvironment);
 }
 
 void Codegen::leaveEnvironment()
 {
-    Q_ASSERT(_env);
-    _env = _env->parent;
+    Q_ASSERT(_variableEnvironment);
+    _variableEnvironment = _variableEnvironment->parent;
 }
 
 void Codegen::enterLoop(Statement *node, IR::BasicBlock *breakBlock, IR::BasicBlock *continueBlock)
@@ -1408,7 +1408,7 @@ bool Codegen::visit(DeleteExpression *ast)
         return false;
     // Temporaries cannot be deleted
     IR::ArgLocal *al = expr->asArgLocal();
-    if (al && al->index < static_cast<unsigned>(_env->members.size())) {
+    if (al && al->index < static_cast<unsigned>(_variableEnvironment->members.size())) {
         // Trying to delete a function argument might throw.
         if (_function->isStrict) {
             throwSyntaxError(ast->deleteToken, QStringLiteral("Delete of an unqualified identifier in strict mode."));
@@ -1437,7 +1437,7 @@ bool Codegen::visit(DeleteExpression *ast)
     }
     if (expr->asTemp() ||
             (expr->asArgLocal() &&
-             expr->asArgLocal()->index >= static_cast<unsigned>(_env->members.size()))) {
+             expr->asArgLocal()->index >= static_cast<unsigned>(_variableEnvironment->members.size()))) {
         _expr.code = _block->CONST(IR::BoolType, 1);
         return false;
     }
@@ -1488,7 +1488,7 @@ IR::Expr *Codegen::identifier(const QString &name, int line, int col)
         return 0;
 
     uint scope = 0;
-    Environment *e = _env;
+    Environment *e = _variableEnvironment;
     IR::Function *f = _function;
 
     while (f && e->parent) {
@@ -1519,7 +1519,7 @@ IR::Expr *Codegen::identifier(const QString &name, int line, int col)
     if (IR::Expr *fallback = fallbackNameLookup(name, line, col))
         return fallback;
 
-    if (!e->parent && (!f || !f->insideWithOrCatch) && _env->compilationMode != EvalCode && e->compilationMode != QmlBinding)
+    if (!e->parent && (!f || !f->insideWithOrCatch) && _variableEnvironment->compilationMode != EvalCode && e->compilationMode != QmlBinding)
         return _block->GLOBALNAME(name, line, col);
 
     // global context or with. Lookup by name
@@ -2014,7 +2014,7 @@ bool Codegen::visit(FunctionDeclaration * ast)
     if (hasError)
         return false;
 
-    if (_env->compilationMode == QmlBinding)
+    if (_variableEnvironment->compilationMode == QmlBinding)
         move(_block->TEMP(_returnAddress), _block->NAME(ast->name.toString(), 0, 0));
     _expr.accept(nx);
     return false;
@@ -2038,26 +2038,26 @@ int Codegen::defineFunction(const QString &name, AST::Node *ast,
 
     IR::BasicBlock *entryBlock = function->newBasicBlock(0);
     IR::BasicBlock *exitBlock = function->newBasicBlock(0, IR::Function::DontInsertBlock);
-    function->hasDirectEval = _env->hasDirectEval || _env->compilationMode == EvalCode
+    function->hasDirectEval = _variableEnvironment->hasDirectEval || _variableEnvironment->compilationMode == EvalCode
             || _module->debugMode; // Conditional breakpoints are like eval in the function
-    function->usesArgumentsObject = _env->parent && (_env->usesArgumentsObject == Environment::ArgumentsObjectUsed);
-    function->usesThis = _env->usesThis;
-    function->maxNumberOfArguments = qMax(_env->maxNumberOfArguments, (int)QV4::Global::ReservedArgumentCount);
-    function->isStrict = _env->isStrict;
-    function->isNamedExpression = _env->isNamedFunctionExpression;
-    function->isQmlBinding = _env->compilationMode == QmlBinding;
+    function->usesArgumentsObject = _variableEnvironment->parent && (_variableEnvironment->usesArgumentsObject == Environment::ArgumentsObjectUsed);
+    function->usesThis = _variableEnvironment->usesThis;
+    function->maxNumberOfArguments = qMax(_variableEnvironment->maxNumberOfArguments, (int)QV4::Global::ReservedArgumentCount);
+    function->isStrict = _variableEnvironment->isStrict;
+    function->isNamedExpression = _variableEnvironment->isNamedFunctionExpression;
+    function->isQmlBinding = _variableEnvironment->compilationMode == QmlBinding;
 
     AST::SourceLocation loc = ast->firstSourceLocation();
     function->line = loc.startLine;
     function->column = loc.startColumn;
 
     if (function->usesArgumentsObject)
-        _env->enter(QStringLiteral("arguments"), Environment::VariableDeclaration, false /* readonly */);
+        _variableEnvironment->enter(QStringLiteral("arguments"), Environment::VariableDeclaration, false /* readonly */);
 
     // variables in global code are properties of the global context object, not locals as with other functions.
-    if (_env->compilationMode == FunctionCode || _env->compilationMode == QmlBinding) {
+    if (_variableEnvironment->compilationMode == FunctionCode || _variableEnvironment->compilationMode == QmlBinding) {
         unsigned t = 0;
-        for (Environment::MemberMap::iterator it = _env->members.begin(), end = _env->members.end(); it != end; ++it) {
+        for (Environment::MemberMap::iterator it = _variableEnvironment->members.begin(), end = _variableEnvironment->members.end(); it != end; ++it) {
             const QString &local = it.key();
             function->LOCAL(local);
             (*it).index = t;
@@ -2065,18 +2065,18 @@ int Codegen::defineFunction(const QString &name, AST::Node *ast,
             ++t;
         }
     } else {
-        if (!_env->isStrict) {
+        if (!_variableEnvironment->isStrict) {
             for (const QString &inheritedLocal : qAsConst(inheritedLocals)) {
                 function->LOCAL(inheritedLocal);
                 unsigned tempIndex = entryBlock->newTemp();
                 Environment::Member member = { Environment::UndefinedMember,
                                                static_cast<int>(tempIndex), 0, false /* readonly */ };
-                _env->members.insert(inheritedLocal, member);
+                _variableEnvironment->members.insert(inheritedLocal, member);
             }
         }
 
         IR::ExprList *args = 0;
-        for (Environment::MemberMap::const_iterator it = _env->members.constBegin(), cend = _env->members.constEnd(); it != cend; ++it) {
+        for (Environment::MemberMap::const_iterator it = _variableEnvironment->members.constBegin(), cend = _variableEnvironment->members.constEnd(); it != cend; ++it) {
             const QString &local = it.key();
             IR::ExprList *next = function->New<IR::ExprList>();
             next->expr = entryBlock->NAME(local, 0, 0);
@@ -2108,11 +2108,11 @@ int Codegen::defineFunction(const QString &name, AST::Node *ast,
         _function->RECEIVE(it->name.toString());
     }
 
-    for (const Environment::Member &member : qAsConst(_env->members)) {
+    for (const Environment::Member &member : qAsConst(_variableEnvironment->members)) {
         if (member.function) {
             const int function = defineFunction(member.function->name.toString(), member.function, member.function->formals,
                                                 member.function->body ? member.function->body->elements : 0);
-            if (! _env->parent) {
+            if (! _variableEnvironment->parent) {
                 move(_block->NAME(member.function->name.toString(), member.function->identifierToken.startLine, member.function->identifierToken.startColumn),
                      _block->CLOSURE(function));
             } else {
@@ -2288,7 +2288,7 @@ bool Codegen::visit(ExpressionStatement *ast)
     if (hasError)
         return true;
 
-    if (_env->compilationMode == EvalCode || _env->compilationMode == QmlBinding) {
+    if (_variableEnvironment->compilationMode == EvalCode || _variableEnvironment->compilationMode == QmlBinding) {
         Result e = expression(ast->expression);
         if (*e)
             move(_block->TEMP(_returnAddress), *e);
@@ -2524,7 +2524,7 @@ bool Codegen::visit(ReturnStatement *ast)
     if (hasError)
         return true;
 
-    if (_env->compilationMode != FunctionCode && _env->compilationMode != QmlBinding) {
+    if (_variableEnvironment->compilationMode != FunctionCode && _variableEnvironment->compilationMode != QmlBinding) {
         throwSyntaxError(ast->returnToken, QStringLiteral("Return statement outside of function"));
         return false;
     }
@@ -2902,7 +2902,7 @@ bool Codegen::visit(UiSourceElement *)
 
 bool Codegen::throwSyntaxErrorOnEvalOrArgumentsInStrictMode(IR::Expr *expr, const SourceLocation& loc)
 {
-    if (!_env->isStrict)
+    if (!_variableEnvironment->isStrict)
         return false;
     if (IR::Name *n = expr->asName()) {
         if (*n->id != QLatin1String("eval") && *n->id != QLatin1String("arguments"))
diff --git a/src/qml/compiler/qv4codegen_p.h b/src/qml/compiler/qv4codegen_p.h
index adfdea8805..712513cd16 100644
--- a/src/qml/compiler/qv4codegen_p.h
+++ b/src/qml/compiler/qv4codegen_p.h
@@ -463,7 +463,7 @@ protected:
     QV4::IR::BasicBlock *_block;
     QV4::IR::BasicBlock *_exitBlock;
     unsigned _returnAddress;
-    Environment *_env;
+    Environment *_variableEnvironment;
     Loop *_loop;
     AST::LabelledStatement *_labelledStatement;
     ScopeAndFinally *_scopeAndFinally;
@@ -541,7 +541,7 @@ protected:
     // fields:
         Codegen *_cg;
         const QString _sourceCode;
-        Environment *_env;
+        Environment *_variableEnvironment;
         QStack<Environment *> _envStack;
 
         bool _allowFuncDecls;