public ForLoopExpression(LexicalScope/*!*/ definedScope, Parameters/*!*/ variables, Expression/*!*/ list, Statements body, SourceSpan location)
            : base(location) {
            Assert.NotNull(definedScope, variables, list);

            _block = new BlockDefinition(definedScope, variables, body, location);
            _list = list;
        }

        public ModuleDefinition(LexicalScope/*!*/ definedScope, ConstantVariable/*!*/ qualifiedName, Body/*!*/ body, SourceSpan location)
            : base(definedScope, body, location)
        {
            ContractUtils.RequiresNotNull(qualifiedName, "qualifiedName");

            _qualifiedName = qualifiedName;
        }

        public ClassDefinition(LexicalScope/*!*/ definedScope, ConstantVariable/*!*/ name, Expression superClass, Body/*!*/ body, SourceSpan location)
            : base(definedScope, name, body, location)
        {
            ContractUtils.RequiresNotNull(name, "name");

            _superClass = superClass;
        }

        public SingletonDefinition(LexicalScope/*!*/ definedScope, Expression/*!*/ singleton, Body/*!*/ body, SourceSpan location)
            : base(definedScope, body, location)
        {
            ContractUtils.RequiresNotNull(singleton, "singleton");

            _singleton = singleton;
        }

        public Initializer(LexicalScope/*!*/ definedScope, List<Expression> statements, SourceSpan location)
            : base(location) {
            Assert.NotNull(definedScope);

            _definedScope = definedScope;
            _statements = statements;
        }

        public Finalizer(LexicalScope/*!*/ definedScope, Statements statements, SourceSpan location)
            : base(location) {
            Assert.NotNull(definedScope);

            _definedScope = definedScope;
            _statements = statements;
        }

 public FunctionDeclarationStatementNode(LexicalScope scope, string name, ParameterNode[] parameters, ElementNode[] body, SourceSpan sourceSpan)
     : base(sourceSpan)
 {
     this.scope = scope;
     this.name = name;
     this.parameters = parameters;
     this.body = body;
 }

        public BlockDefinition(LexicalScope/*!*/ definedScope, CompoundLeftValue/*!*/ parameters, Statements/*!*/ body, SourceSpan location)
            : base(location) {
            Assert.NotNull(definedScope, parameters, body);

            _definedScope = definedScope;
            _body = body;
            _parameters = parameters;
        }

        public BlockDefinition(LexicalScope definedScope, CompoundLeftValue/*!*/ parameters, List<Expression>/*!*/ body, SourceSpan location)
            : base(location) {
            Assert.NotNull(parameters, body);

            _definedScope = definedScope;
            _body = body;
            _parameters = parameters;
        }

        public BlockDefinition(LexicalScope/*!*/ definedScope, Parameters parameters, Statements/*!*/ body, SourceSpan location)
            : base(location) {
            Assert.NotNull(definedScope, body);

            _definedScope = definedScope;
            _body = body;
            _parameters = parameters ?? Parameters.Empty; 
        }

        protected DefinitionExpression(LexicalScope/*!*/ definedScope, Body/*!*/ body, SourceSpan location) 
            : base(location) {
            ContractUtils.RequiresNotNull(definedScope, "definedScope");
            ContractUtils.RequiresNotNull(body, "body");

            _definedScope = definedScope;
            _body = body;
        }

        internal override Expression/*!*/ ToCondition(LexicalScope/*!*/ currentScope) {
            var newExpression = _expression.ToCondition(currentScope);
            if (newExpression != _expression) {
                return new NotExpression(newExpression, Location);
            }

            return this;
        }

        private void CompileLet(object form, LexicalScope lexScope)
        {
            throw new NotImplementedException();
              // Cons consForm = form as Cons;
              // if(consForm == null)
              // {
              //   throw new CompilerError("{0} is not let-form!", form);
              // }

              // Cons formArgs = consForm.Tail as Cons;
              // if(formArgs == null)
              // {
              //   throw new CompilerError("{0} is not let-form!", form);
              // }

              // Cons bindingList = formArgs.Head as Cons;
              // if(bindingList == null)
              // {
              //   throw new CompilerError("{0} is not let-form!", form);
              // }

              // while(bindingList != Cons.Nil)
              // {
              //   object arg = bindingList.Head;
              //   String type = TypeResolver.GetTypeRef(arg.GetType());
              //   switch(type)
              //   {
              //     case "symbol":
              //       lexScope.Bind(arg as Symbol, "value", Cons.Nil);
              //       break;

              //     case "cons":
              //       Cons argSpec = arg as Cons;
              //       Symbol sym = argSpec.Head as Symbol;
              //       if(sym == null)
              //       {
              //         throw new TypeError(argSpec.Head, typeof(Symbol));
              //       }
              //       Cons specTail = argSpec.Tail as Cons;
              //       if(specTail == null)
              //       {
              //         throw new TypeError(specTail.Tail, typeof(Cons));
              //       }
              //       object value = specTail.Head;
              //       lexScope.Bind(sym, "value", value);
              //       break;
              //     default:
              //       throw new TypeError(arg, typeof(Symbol));
              //   }

              //   Cons newArgs = bindingList.Tail as Cons;
              //   if(newArgs == null)
              //   {
              //     throw new TypeError(newArgs, typeof(Cons));
              //   }
              //   bindingList = newArgs;
              // }
        }

        public MethodDefinition(LexicalScope/*!*/ definedScope, Expression target, string/*!*/ name, Parameters parameters, Body/*!*/ body, 
            SourceSpan location)
            : base(definedScope, body, location) {
            Assert.NotNull(name);

            _target = target;
            _name = name;
            _parameters = parameters ?? Parameters.Empty;
        }

        public ArgumentVariable(int index, string name, LexicalScope parentScope, IChelaType type)
            : base(type, parentScope.GetModule())
        {
            base.SetName(name);
            this.parentScope = parentScope;

            // Add the variable into the scope.
            this.index = index;
            parentScope.AddArgument(this);
        }

 internal override Expression/*!*/ ToCondition(LexicalScope/*!*/ currentScope) {
     int intBegin, intEnd;
     if (!IsIntegerRange(out intBegin, out intEnd)) {
         return new RangeCondition(
             this,
             currentScope.GetInnerMostTopScope().AddVariable("#FlipFlopState" + Interlocked.Increment(ref _flipFlopVariableId), Location)
         );
     }
     return this;
 }

 public ForStatementNode(LexicalScope scope, StatementNode initializer, ExpressionNode condition,
     ExpressionNode incrementer, StatementNode body, SourceSpan span)
     : base(span)
 {
     this.scope = scope;
     this.initializer = initializer;
     this.condition = condition;
     this.incrementer = incrementer;
     this.body = body;
 }

        internal override Expression/*!*/ ToCondition(LexicalScope/*!*/ currentScope) {
            var newLeft = _left.ToCondition(currentScope);
            var newRight = _right.ToCondition(currentScope);

            if (newLeft != _left || newRight != _right) {
                return new OrExpression(newLeft, newRight, Location);
            }

            return this;
        }

        public MethodDefinition(LexicalScope/*!*/ definedScope, Expression target, string/*!*/ name, Parameters parameters, Body/*!*/ body, 
            SourceSpan location)
            : base(definedScope, body, location)
        {
            Assert.NotNull(name);

            // only for-loop block might use other than local variable for unsplat:
            Debug.Assert(parameters.Unsplat == null || parameters.Unsplat is LocalVariable);

            _target = target;
            _name = name;
            _parameters = parameters ?? Parameters.Empty;
        }

        public ScopeBuilder(AstParameters parameters, int firstClosureParam, int localCount, 
            ScopeBuilder parent, LexicalScope/*!*/ lexicalScope) {
            Debug.Assert(parent == null || parent.LexicalScope == lexicalScope.OuterScope);
#if DEBUG
            _id = Interlocked.Increment(ref _Id);
#endif
            _parent = parent;
            _parameters = parameters;
            _localCount = localCount;
            _firstClosureParam = firstClosureParam;
            _lexicalScope = lexicalScope;
            _hiddenVariables = new AstParameters();
            _localsTuple = DefineHiddenVariable("#locals", MakeLocalsTupleType());
            _outermostClosureReferredTo = this;
        }