public TalDefine(Tag tag, VariableScope scope, string name, string expression)
     : base(tag, CommandType.TalDefine)
 {
     Scope = scope;
     Name = name;
     Expression = expression;
 }

 public AssignStringLiteral(Int32 destinationDestIndex, VariableScope destinationDestScope, Int32 sourceIndex,
                            VariableScope sourceScope)
 {
     m_DestIndex = destinationDestIndex;
     m_DestScope = destinationDestScope;
     m_SourceIndex = sourceIndex;
     m_SourceScope = sourceScope;
 }

 public VariablesHierarchyInfoDto(VariableScope scope, int scopeID, string scopeName)
 {
     this.ScopeKey = scope.GetName();
     this.ScopeID = scopeID;
     this.ScopeName = scopeName;
     this.Variables = new List<VariableDto>();
     this.Children = new List<VariablesHierarchyInfoDto>();
 }

        public VariableResolver(IVariableStorage varStorage, AnalysisScope scope = AnalysisScope.File)
        {
            Preconditions.NotNull(varStorage, "varStorage");
            this._variableStorage = varStorage;
            this._scope = scope;

            variableScope = scope == AnalysisScope.File ? VariableScope.File : VariableScope.Function;
        }

 public static Scope Create(VariableScope scope)
 {
     return new Scope
     {
         Name = scope.Name,
         VariablesReference = scope.Id
     };
 }

        public AssignString(Int32 destIndex, VariableScope destScope, Expression expression)
        {
            m_DestIndex = destIndex;
            m_DestScope = destScope;
            m_Expression = expression;

            if (expression.ReturnType != GossipType.String)
                throw new GossipScriptException("Expression must return type string");
        }

        public MTSSetTransactionStatement(VariableScope scope, IsolationLevel level)
        {
            if (level == IsolationLevel.None)
            {
                throw new ArgumentException("isolation level is null");
            }

            Level = level;
            Scope = scope;
        }

        public AstHelper(ModuleBuilder moduleBuilder)
        {
            ModuleBuilder = moduleBuilder;
            Expecting = new Expecting();
            Functions = new FunctionScope();
            Variables = new VariableScope();
            Types = new TypeScope();
            Errors = new ErrorSet();

            ReturnScope = new ReturnScope();
        }

 public LocalDefinition DefineLocal(ParameterExpression variable, int start)
 {
     VariableScope scope;
     VariableScope scope2;
     LocalVariable variable2 = new LocalVariable(this._localCount++, false, false);
     this._maxLocalCount = Math.Max(this._localCount, this._maxLocalCount);
     if (this._variables.TryGetValue(variable, out scope))
     {
         scope2 = new VariableScope(variable2, start, scope);
         if (scope.ChildScopes == null)
         {
             scope.ChildScopes = new List<VariableScope>();
         }
         scope.ChildScopes.Add(scope2);
     }
     else
     {
         scope2 = new VariableScope(variable2, start, null);
     }
     this._variables[variable] = scope2;
     return new LocalDefinition(variable2.Index, variable);
 }

        public void LeaveMethodDefinition() {
            Debug.Assert(_currentElement == _currentMethod);
            MethodScope oldMethod = _currentMethod;

            _currentElement = oldMethod.Parent;
            _currentRescue = oldMethod.ParentRescue;
            _currentLoop = oldMethod.ParentLoop;
            _currentBlock = oldMethod.ParentBlock;
            _currentVariableScope = oldMethod.ParentVariableScope;
            _currentMethod = oldMethod.ParentMethod;
        }

        public void EnterMethodDefinition(
            ScopeBuilder/*!*/ locals, 
            MSA.Expression/*!*/ selfParameter,
            MSA.ParameterExpression/*!*/ runtimeScopeVariable,
            MSA.Expression blockParameter,
            string/*!*/ methodName,
            Parameters parameters) {
            Assert.NotNull(locals, selfParameter, runtimeScopeVariable);

            MethodScope method = new MethodScope(
                locals,
                selfParameter, 
                runtimeScopeVariable, 
                blockParameter, 
                methodName, 
                parameters
            );

            method.Parent = _currentElement;
            method.ParentRescue = _currentRescue;
            method.ParentLoop = _currentLoop;
            method.ParentBlock = _currentBlock;
            method.ParentVariableScope = _currentVariableScope;
            method.ParentMethod = _currentMethod;

            _currentElement = method;
            _currentRescue = null;
            _currentLoop = null;
            _currentBlock = null;
            _currentVariableScope = method;
            _currentMethod = method;
        }

        public void LeaveBlockDefinition() {
            Debug.Assert(_currentElement == _currentBlock);
            BlockScope oldBlock = _currentBlock;

            _currentElement = oldBlock.Parent;
            _currentRescue = oldBlock.ParentRescue;
            _currentLoop = oldBlock.ParentLoop;
            _currentVariableScope = oldBlock.ParentVariableScope;
            _currentBlock = oldBlock.ParentBlock;
        }

        public void EnterBlockDefinition(
            ScopeBuilder/*!*/ locals,
            MSA.Expression/*!*/ bfcVariable,
            MSA.Expression/*!*/ selfVariable,
            MSA.ParameterExpression/*!*/ runtimeScopeVariable, 
            MSA.LabelTarget/*!*/ redoLabel) {
            Assert.NotNull(locals, bfcVariable, selfVariable);
            Assert.NotNull(redoLabel);

            BlockScope block = new BlockScope(locals, selfVariable, runtimeScopeVariable, bfcVariable, redoLabel);
            block.Parent = _currentElement;
            block.ParentRescue = _currentRescue;
            block.ParentLoop = _currentLoop;
            block.ParentBlock = _currentBlock;
            block.ParentVariableScope = _currentVariableScope;
            
            _currentElement = block;
            _currentRescue = null;
            _currentLoop = null;
            _currentBlock = block;
            _currentVariableScope = block;
        }

		/// <summary>
		/// Append a variable parameter encoded Int32
		/// </summary>
		/// <param name="value">Value to append</param>
		/// <param name="scope">Select either global or local scope</param>
		/// <param name="type">Select either value or handle scope</param>
		public void Append(Int32 value, VariableScope scope, VariableType type){
			Append(scope, type, FollowType.FourBytes);
			Append(value);
		}

        public void LeaveSourceUnit() {
            Debug.Assert(_currentElement == _currentMethod && _currentVariableScope == _currentMethod);
            Debug.Assert(_currentLoop == null && _currentRescue == null);
            Debug.Assert(_currentBlock == null);

            _currentElement = null;
            _currentMethod = null;
            _currentVariableScope = null;
        }

        public LocalDefinition DefineLocal(ParameterExpression variable, int start)
        {
            LocalVariable result = new LocalVariable(_localCount++, false, false);
            _maxLocalCount = System.Math.Max(_localCount, _maxLocalCount);

            VariableScope existing, newScope;
            if (_variables.TryGetValue(variable, out existing))
            {
                newScope = new VariableScope(result, start, existing);
                if (existing.ChildScopes == null)
                {
                    existing.ChildScopes = new List<VariableScope>();
                }
                existing.ChildScopes.Add(newScope);
            }
            else
            {
                newScope = new VariableScope(result, start, null);
            }

            _variables[variable] = newScope;
            return new LocalDefinition(result.Index, variable);
        }

        public void LeaveFileInitializer() {
            Debug.Assert(_currentElement == _currentVariableScope);
            VariableScope oldScope = _currentVariableScope;

            _currentElement = oldScope.Parent;
            _currentVariableScope = oldScope.ParentVariableScope;
        }

 private IModel GetModel(VariableScope scope)
 {
     switch (scope)
     {
         case VariableScope.Global:
             return GLOBAL;
         case VariableScope.Model:
             return _model;
         case VariableScope.Page:
             return _page;
         case VariableScope.Request:
             return _session;
         case VariableScope.Session:
             return _session;
         case VariableScope.Tag:
             return _hasTags ? _tagVariables.Peek() : null;
         default:
             throw new NotImplementedException("GetModel not implemented for " + scope);
     }
 }

        public void EnterFileInitializer(
            ScopeBuilder/*!*/ locals,
            MSA.Expression/*!*/ selfVariable,
            MSA.ParameterExpression/*!*/ runtimeScopeVariable) {

            VariableScope scope = new VariableScope(locals, selfVariable, runtimeScopeVariable);

            scope.Parent = _currentElement;
            scope.ParentVariableScope = _currentVariableScope;

            _currentElement = scope;
            _currentVariableScope = scope;
        }

 public SysVarPrimary(VariableScope scope, string varText, string varTextUp)
 {
     Scope = scope;
     this.varText = varText;
     VarTextUp = varTextUp;
 }