protected virtual IndexExpression UpdateIndexExpression(IndexExpression exp, Expression obj, ReadOnlyCollection<Expression> args)
 {
     if (exp.Object != obj || exp.Arguments != args)
     {
         return Expression.MakeIndex(obj, exp.Indexer, args);
     }
     return exp;
 }

            public IndexVisitor(IndexExpression expr, Expression newObject, Expression[] newArguments)
            {
                _dict = new Dictionary<Expression, Expression>
                {
                    {expr.Object, newObject}
                };

                for (int i = 0; i < expr.Arguments.Count; i++)
                {
                    _dict.Add(expr.Arguments[i], newArguments?[i]);
                }
            }

		/////////////////////////////////////////////////////////////////////////////

		public override object EvalIndexExpression( object objIn, IndexExpression exp )
		{
			// ******
			//
			// expression:  macro.fieldOrProperty[ i ]
			//
			// exp.MemberName should be the name of an indexer (property with arguments)
			// that we need to access
			//
			var invoker = Invokers.GetIndexerInvoker( objIn, exp.MemberName, typeHelpers );
			if( null == invoker ) {
				ThreadContext.MacroError( "there is no indexer named \"{0}\" on the object type \"{1}\"", exp.MemberName, ObjectInfo.GetTypeName(objIn) );
			}
			object objResult = invoker.Invoke( EvaluateArguments(exp.Arguments) );

			// ******
			CheckNullResult( objResult, objIn, exp.MemberName );
			return objResult;
		}

 public IndexExpressionProxy(IndexExpression node) {
     _node = node;
 }

		public abstract string DumpIndexExpression( IndexExpression exp );

 public virtual void PostWalk(IndexExpression node) { }

        private WriteBack AddressOfWriteBackCore(IndexExpression node)
        {
            // emit instance, if any
            LocalBuilder instanceLocal = null;
            Type instanceType = null;
            if (node.Object != null)
            {
                EmitInstance(node.Object, out instanceType);

                // store in local
                _ilg.Emit(OpCodes.Dup);
                _ilg.Emit(OpCodes.Stloc, instanceLocal = GetInstanceLocal(instanceType));
            }

            // Emit indexes. We don't allow byref args, so no need to worry
            // about write-backs or EmitAddress
            int n = node.ArgumentCount;
            var args = new LocalBuilder[n];
            for (var i = 0; i < n; i++)
            {
                Expression arg = node.GetArgument(i);
                EmitExpression(arg);

                LocalBuilder argLocal = GetLocal(arg.Type);
                _ilg.Emit(OpCodes.Dup);
                _ilg.Emit(OpCodes.Stloc, argLocal);
                args[i] = argLocal;
            }

            // emit the get
            EmitGetIndexCall(node, instanceType);

            // emit the address of the value
            LocalBuilder valueLocal = GetLocal(node.Type);
            _ilg.Emit(OpCodes.Stloc, valueLocal);
            _ilg.Emit(OpCodes.Ldloca, valueLocal);

            // Set the property after the method call
            // don't re-evaluate anything
            return @this =>
            {
                if (instanceLocal != null)
                {
                    @this._ilg.Emit(OpCodes.Ldloc, instanceLocal);
                    @this.FreeLocal(instanceLocal);
                }
                foreach (LocalBuilder arg in args)
                {
                    @this._ilg.Emit(OpCodes.Ldloc, arg);
                    @this.FreeLocal(arg);
                }
                @this._ilg.Emit(OpCodes.Ldloc, valueLocal);
                @this.FreeLocal(valueLocal);

                @this.EmitSetIndexCall(node, instanceLocal?.LocalType);
            };
        }

        private void AddressOf(IndexExpression node, Type type)
        {
            if (!TypeUtils.AreEquivalent(type, node.Type) || node.Indexer != null)
            {
                EmitExpressionAddress(node, type);
                return;
            }

            if (node.ArgumentCount == 1)
            {
                EmitExpression(node.Object);
                EmitExpression(node.GetArgument(0));
                _ilg.Emit(OpCodes.Ldelema, node.Type);
            }
            else
            {
                MethodInfo address = node.Object.Type.GetMethod("Address", BindingFlags.Public | BindingFlags.Instance);
                EmitMethodCall(node.Object, address, node);
            }
        }

 // IndexExpression
 public override bool Walk(IndexExpression node) { return Location >= node.StartIndex && Location <= node.EndIndex; }

		public abstract object EvalIndexExpression( object obj, IndexExpression exp );

 protected virtual Expression VisitIndexExpression(IndexExpression exp)
 {
     var obj = this.Visit(exp.Object);
     var args = this.VisitExpressionList(exp.Arguments);
     return this.UpdateIndexExpression(exp, obj, args);
 }

        protected override Expression VisitIndexExpression(IndexExpression exp)
        {
            Accumulate(exp.Indexer);

            return base.VisitIndexExpression(exp);
        }

 protected virtual Expression VisitIndex(IndexExpression index)
 {
     return index;
 }

 public override bool Walk(IndexExpression node)
 {
     node.Parent = _currentScope;
     return base.Walk(node);
 }

 private void EmitSetIndexCall(IndexExpression node, Type objectType) {
     if (node.Indexer != null) {
         // For indexed properties, just call the setter
         var method = node.Indexer.GetSetMethod(true);
         EmitCall(objectType, method);
     } else if (node.Arguments.Count != 1) {
         // Multidimensional arrays, call set
         _ilg.Emit(OpCodes.Call, node.Object.Type.GetMethod("Set", BindingFlags.Public | BindingFlags.Instance));
     } else {
         // For one dimensional arrays, emit store
         _ilg.EmitStoreElement(node.Type);
     }
 }

		/////////////////////////////////////////////////////////////////////////////

		protected Expression IndexMember( bool isRootNode, string memberName, bool validToken, IInput input )
		{
			// ******
			Expression expression = null;

			//IArgumentsProcessor ap = new ArgumentsProcessor( argScanner, recognizer );
			IArgumentsProcessor ap = new ArgumentsProcessor( scanner, recognizer );

			//NmpStringList strArgs = argScanner( input, RecognizedCharType.CloseBracketChar );
			NmpStringList strArgs = scanner.ArgScanner( input, RecognizedCharType.CloseBracketChar );

			// ******
			if( ! validToken ) {
				//
				// IndexResult
				//
				return new UnnamedIndexExpression( ap, strArgs );
			}
			else {
				if( isRootNode ) {
					expression = new UnnamedIndexExpression(memberName, ap, strArgs );
				}
				else {
					expression = new IndexExpression( memberName, ap, strArgs );
				}
			}

			// ******
			return expression;
		}

        private WriteBack AddressOfWriteBack(IndexExpression node)
        {
            if (node.Indexer == null || !node.Indexer.CanWrite)
            {
                return null;
            }

            return AddressOfWriteBackCore(node); // avoids closure allocation
        }

        private void AddressOf(IndexExpression node, Type type) {
            if (type != node.Type || node.Indexer != null) {
                EmitExpressionAddress(node, type);
                return;
            }

            if (node.Arguments.Count == 1) {
                EmitExpression(node.Object);
                EmitExpression(node.Arguments[0]);
                _ilg.Emit(OpCodes.Ldelema, node.Type);
            } else {
                var address = node.Object.Type.GetMethod("Address", BindingFlags.Public | BindingFlags.Instance);
                EmitMethodCall(node.Object, address, node);
            }
        }

 // IndexExpression
 public override bool Walk(IndexExpression node) { return false; }

        private WriteBack AddressOfWriteBack(IndexExpression node)
        {
            if (node.Indexer == null || !node.Indexer.CanWrite)
            {
                return null;
            }

            // emit instance, if any
            LocalBuilder instanceLocal = null;
            Type instanceType = null;
            if (node.Object != null)
            {
                EmitInstance(node.Object, instanceType = node.Object.Type);

                _ilg.Emit(OpCodes.Dup);
                _ilg.Emit(OpCodes.Stloc, instanceLocal = GetLocal(instanceType));
            }

            // Emit indexes. We don't allow byref args, so no need to worry
            // about writebacks or EmitAddress
            List<LocalBuilder> args = new List<LocalBuilder>();
            foreach (var arg in node.Arguments)
            {
                EmitExpression(arg);

                var argLocal = GetLocal(arg.Type);
                _ilg.Emit(OpCodes.Dup);
                _ilg.Emit(OpCodes.Stloc, argLocal);
                args.Add(argLocal);
            }

            // emit the get
            EmitGetIndexCall(node, instanceType);

            // emit the address of the value
            var valueLocal = GetLocal(node.Type);
            _ilg.Emit(OpCodes.Stloc, valueLocal);
            _ilg.Emit(OpCodes.Ldloca, valueLocal);

            // Set the property after the method call
            // don't re-evaluate anything
            return delegate ()
            {
                if (instanceLocal != null)
                {
                    _ilg.Emit(OpCodes.Ldloc, instanceLocal);
                    FreeLocal(instanceLocal);
                }
                foreach (var arg in args)
                {
                    _ilg.Emit(OpCodes.Ldloc, arg);
                    FreeLocal(arg);
                }
                _ilg.Emit(OpCodes.Ldloc, valueLocal);
                FreeLocal(valueLocal);

                EmitSetIndexCall(node, instanceType);
            };
        }