protected virtual Exp ResolveExpAsLeft(ISemanticResolver s)
 {
     // Default impl - most expressions aren't valid on the LHS.
     //s.ThrowError_NotValidLHS(this.Location);
     ThrowError(SymbolError.NotValidLHS(this.Location));
     return null;
 }

 // Resolve expression as a RHS value. The exp node can totally change on us
 // (operator overloading, constant folding, etc), so we must pass as a ref
 public static void ResolveExpAsRight(ref Exp e, ISemanticResolver s)
 {
     // Debugging helper. Useful when we want to break when resolving 
     // a particular symbol.
     
     #if false   
          
     // Set lTarget to a symbol that we want to see resolved.
     FileRange lTarget = new FileRange("SemanticChecker.cs", 143, 39, 143, 43);
     if (lTarget.Equals(e.Location))
     {
         System.Diagnostics.Debugger.Break();
     }
     
     #endif
     e = e.ResolveExpAsRight(s);
     Debug.Assert(e != null);
 }

    // Determine the CLR type of this expression
    protected override Type CalcCLRTypeHelper(ISemanticResolver s)
    {
        switch(m_op)
        {
            case UnaryOp.cNegate:
                return typeof(int);
            case UnaryOp.cNot:
                return typeof(bool);

            case UnaryOp.cPreInc:
                return typeof(int);

            case UnaryOp.cPostInc:
                return typeof(int);

            case UnaryOp.cPreDec:
                return typeof(int);

            case UnaryOp.cPostDec:
                return typeof(int);
        
            default:
                Debug.Assert(false, "Illegal unary operator:" + m_op.ToString());
                return null;
        }
        
    }

 public override void DebugCheck(ISemanticResolver s)
 {
     m_exp.DebugCheck(s);
 }

 public DeclareLocalStmtExp(System.Type t, ISemanticResolver s)
     : this(s.ResolveCLRTypeToBlueType(t))
 {           
 }