示例#1
0
        // Debugging support
        public override void DebugCheck(ISemanticResolver s)
        {
            //Debug.Assert(AST.Node.m_DbgAllowNoCLRType || m_typeCLR != null);
            if (Node != null)
            {
                Debug.Assert(Node.Symbol == this);

                // Non-null means that we're a user method. So we'd better
                // have a scope
                Debug.Assert(m_scope != null);
                m_scope.DebugCheck(s);
            }
            else
            {
                // If Node is null, then we're imported.
                // Can't have a scope & body for an imported function...
                Debug.Assert(m_scope == null);
            }


            if (!IsCtor)
            {
                // Must have a return type (even Void is still non-null)
                Debug.Assert(RetType != null);
                RetType.DebugCheck(s);
            }

            // Must be defined in some class
            Debug.Assert(m_classDefined != null);
        }
示例#2
0
文件: ExpAST.cs 项目: chenzuo/blue
 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;
 }
示例#3
0
        // Imported
        public MethodExpEntry(
            ISemanticResolver s,
            System.Reflection.MethodBase info // CLR info for this method
            )
        {
            Debug.Assert(info != null);

            this.m_infoMethod = info;

            this.m_fIsSpecialName = info.IsSpecialName;
            this.m_strName        = info.Name;
            this.m_classDefined   = s.ResolveCLRTypeToBlueType(info.DeclaringType);

            // Set return type for non-constructors
            System.Reflection.MethodInfo mInfo = info as System.Reflection.MethodInfo;
            if (mInfo != null)
            {
                // not a ctor
                this.m_type = s.ResolveCLRTypeToBlueType(mInfo.ReturnType);
            }
            else
            {
                // ctor
                this.m_type = null;
                m_strName   = m_classDefined.Name;
            }
        }
示例#4
0
 // Resolve this array initializer list.
 // Provide with the type that we expect each element in the list to be
 public void Resolve(ISemanticResolver s, TypeEntry tExpected)
 {
     // Each node must either be an expression or a nested array initializer list
     //foreach(Node n in List)
     for(int i = 0; i < m_list.Length; i++)
     {
         Node n = m_list[i]; 
         if (n is Exp)
         {
             Exp e = (Exp) n;
             Exp.ResolveExpAsRight(ref e, s);
             m_list[i] = e;
             
             s.EnsureAssignable(e, tExpected.CLRType);
         } 
         
         else if (n is ArrayInitializer)
         {
             Debug.Assert(tExpected.IsArray); // @todo -legit
             
             ArrayInitializer a = (ArrayInitializer) n;
             TypeEntry tNested = tExpected.AsArrayType.ElemType;
             
             a.Resolve(s, tNested);
         }
         
         else 
         {
             // Error
             Debug.Assert(false); // @todo - legit
         }
     
     }
 }
示例#5
0
 public ResolvedTypeSig(System.Type t, ISemanticResolver s)
 {
     Debug.Assert(!t.IsByRef, "Don't expect ref types");
     Debug.Assert(t != null);
     Debug.Assert(s != null);
     m_type = s.ResolveCLRTypeToBlueType(t);
 }
示例#6
0
 public override void DebugCheck(ISemanticResolver s)    
 {
     foreach(Node n in List)
     {
         n.DebugCheck(s);
     }
 }
示例#7
0
 public override void DebugCheck(ISemanticResolver s)
 {        
     Debug.Assert(m_type != null);
     TypeEntry t = BlueType;
     
     if (t.IsRef)
         return;
     
     System.Type clrType = t.CLRType;
     
     // Make sure that our CLR type matches our TypeEntry
     if (clrType != null)
     {
         // @todo - Enums aren't entered into the hash.
         if (!(t is EnumTypeEntry))
         {
             TypeEntry t2 = s.ResolveCLRTypeToBlueType(clrType);
             Debug.Assert(t == t2);
         }
     }
     if (clrType == null)
     {   
         // Even now, the only way we can have no clr type is if we
         // are a user declared class
         Debug.Assert(t.Node != null);            
     }
             
 } // DebugCheck   
示例#8
0
 // Semantic resolution
 public override void ResolveType(ISemanticResolver s)
 {
     if (m_ArrayTypeRec != null)
         return;
         
     m_sigBase.ResolveType(s);
     m_ArrayTypeRec = new ArrayTypeEntry(this, s);
 }
示例#9
0
 // Semantic resolution
 public override void ResolveType(ISemanticResolver s)
 {        
     if (m_tRefEntry != null)
         return;
         
     m_tElem.ResolveType(s);
     
     m_tRefEntry = new RefTypeEntry(m_tElem.BlueType, s);
 }
示例#10
0
 // Semantic resolution
 public override void ResolveType(ISemanticResolver s)
 {
     if (m_type != null)
         return;
         
     Exp.ResolveExpAsRight(ref m_oeValue, s);
             
     Debug.Assert(m_oeValue is TypeExp);                
     m_type = ((TypeExp) m_oeValue).Symbol;
 }
示例#11
0
 // Create an array node given an existing CLR array type
 public ArrayTypeSig(System.Type tArray, ISemanticResolver s)    
 {
     Debug.Assert(tArray != null);
     
     m_filerange = null;
     m_cDimension = tArray.GetArrayRank();        
     Debug.Assert(m_cDimension == 1, "@todo - only 1d arrays currently implemented");
     
     m_ArrayTypeRec = s.ResolveCLRTypeToBlueType(tArray).AsArrayType;
     m_sigBase = null; // left as null.
 }
示例#12
0
        // Verify integrity of all symbol elements in this scope
        public void DebugCheck(ISemanticResolver s)
        {
            System.Collections.IDictionaryEnumerator e = m_table.GetEnumerator();
            while (e.MoveNext())
            {
                string   str = (string)e.Key;
                SymEntry sym = (SymEntry)e.Value;

                sym.DebugCheck(s);
            }
        }
示例#13
0
        // Imported field
        public FieldExpEntry(
            ISemanticResolver s,
            System.Reflection.FieldInfo fInfo
            )
        {
            m_strName       = fInfo.Name;
            m_type          = s.ResolveCLRTypeToBlueType(fInfo.FieldType);
            m_nodeDecl      = null;
            m_tClassDefined = s.ResolveCLRTypeToBlueType(fInfo.DeclaringType);

            m_info = fInfo;
        }
示例#14
0
        public override void DebugCheck(ISemanticResolver s)
        {
            Debug.Assert(Name != null);
            if (Node != null)
            {
                Debug.Assert(Node.Symbol == this);
            }
            Debug.Assert(Info != null);
            Debug.Assert(SymbolClass != null);
            Debug.Assert(FieldType != null);

            SymbolClass.DebugCheck(s);
            FieldType.DebugCheck(s);
        }
示例#15
0
 public override void DebugCheck(ISemanticResolver s)
 {
     ElemType.DebugCheck(s);
     Debug.Assert(m_ArrayTypeRec != null);
         
     // Parallel data structures:
     // (ArrayTypeSig : TypeSig) as (ArrayTypeEntry : TypeEntry)
     // So verify the integrity there
     if (m_sigBase != null)
     {
         Debug.Assert(m_sigBase.BlueType == m_ArrayTypeRec.ElemType);
     }
             
 } // DebugCheck
示例#16
0
        // For imported
        public LiteralFieldExpEntry(
            ISemanticResolver s,
            System.Reflection.FieldInfo fInfo
            ) : base(s, fInfo)
        {
            Debug.Assert(fInfo.IsLiteral && fInfo.IsStatic);

            object o = fInfo.GetValue(null);

            // For enum fields, their literal value is an Enum, not an int.


            Data = o;
            Type   t  = m_value.GetType();
            string st = m_value.ToString();
        }
示例#17
0
文件: ExpAST.cs 项目: chenzuo/blue
 // 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);
 }
示例#18
0
        // Ctor for imported properties
        public PropertyExpEntry(
            ISemanticResolver s,
            System.Reflection.PropertyInfo info
            )
        {
            m_info = info;

            m_strName = m_info.Name;

            // Class that we're defined in?
            System.Type tClrClass = info.DeclaringType;
            m_tClassDefined = s.ResolveCLRTypeToBlueType(tClrClass);

            // Symbol type
            this.m_type = s.ResolveCLRTypeToBlueType(info.PropertyType);

            // Spoof accessors
            if (info.CanRead) // Has Get
            {
                System.Reflection.MethodInfo mGet = info.GetGetMethod();
                m_symbolGet = new MethodExpEntry(s, mGet);
            }

            if (info.CanWrite) // Has Set
            {
                System.Reflection.MethodInfo mSet = info.GetSetMethod();
                m_symbolSet = new MethodExpEntry(s, mSet);
            }

            // Get modifiers
            System.Reflection.MethodInfo [] m = info.GetAccessors();

            m_mods = new Modifiers(m[0]);

            /*
             * m_mods = new Modifiers();
             * if (m[0].IsStatic) m_mods.SetStatic();
             * if (m[0].IsAbstract) m_mods.SetAbstract();
             * if (m[0].IsVirtual) m_mods.SetVirtual();
             */
        }
示例#19
0
        // Imported events
        public EventExpEntry(
            System.Reflection.EventInfo eInfo,
            ISemanticResolver s
            )
        {
            Debug.Assert(eInfo != null);
            Debug.Assert(s != null);

            this.m_strName       = eInfo.Name;
            this.m_tClassDefined = s.ResolveCLRTypeToBlueType(eInfo.DeclaringType);
            this.m_type          = s.ResolveCLRTypeToBlueType(eInfo.EventHandlerType);

            this.m_node = null;

            System.Reflection.MethodInfo mAdd    = eInfo.GetAddMethod();
            System.Reflection.MethodInfo mRemove = eInfo.GetRemoveMethod();

            SetAddMethod(new MethodExpEntry(s, mAdd));
            SetRemoveMethod(new MethodExpEntry(s, mRemove));

            this.m_mods = new Modifiers(mAdd);
        }
示例#20
0
文件: ExpAST.cs 项目: chenzuo/blue
 // Resolve the expression as a LHS value
 protected override Exp ResolveExpAsLeft(ISemanticResolver s)
 {
     Debug.Assert(m_eFlow == EArgFlow.cOut | m_eFlow == EArgFlow.cRef);
     ResolveExpAsLeft(ref m_exp, s);
     CalcCLRType(s);
     return this;
 }
示例#21
0
文件: ExpAST.cs 项目: chenzuo/blue
 protected override Type CalcCLRTypeHelper(ISemanticResolver s)
 {
     // Get the type of our inner
     Type t = m_exp.CalcCLRType(s);
     
     // If we've already got a reference, then we're ok.
     // Also ok if we're null (since literals can't be passed as a ref/out)
     if ((t == null) || (t.IsByRef))
         return t;
     
     // Ref & Out params are actually type 'T&', not 'T'
     if (Flow == EArgFlow.cRef || Flow == EArgFlow.cOut)
     {
         t = s.GetRefToType(t);        
     }
     
     return t;
 }
示例#22
0
文件: ExpAST.cs 项目: chenzuo/blue
 // There's nothing to resolve here. No real action happens until
 // codegen...
 protected override Exp ResolveExpAsRight(ISemanticResolver s)
 {           
     return this;
 }
示例#23
0
文件: ExpAST.cs 项目: chenzuo/blue
 //.........................................................................
 // Semantic resolution. Resolve the exp as either a LHS or RHS value.
 //.........................................................................
 
 // Resolve the expression as a LHS value
 public static void ResolveExpAsLeft(ref Exp e, ISemanticResolver s)
 {
     e = e.ResolveExpAsLeft(s);
     Debug.Assert(e != null);
 }
示例#24
0
文件: ExpAST.cs 项目: chenzuo/blue
 // Allow safe resolving on Statement Exp. Allowed to change to another StmtExp
 public static void ResolveExpAsRight(ref StatementExp se, ISemanticResolver s)
 {
     Exp e = se;
     Exp.ResolveExpAsRight(ref e, s);
     if (e is StatementExp)
         se = (StatementExp) e;
     else
         Debug.Assert(false, "Shouldn't have resolved to a non-stmtexp");            
         
     Debug.Assert(se != null);
 }
示例#25
0
文件: ExpAST.cs 项目: chenzuo/blue
 // Semantic resolution
 protected override Exp ResolveExpAsRight(ISemanticResolver s)
 {
     Debug.Assert(false);        
     return null;
 }    
示例#26
0
文件: ExpAST.cs 项目: chenzuo/blue
 // Semantic resolution.
 // This is where we check for Set-Property transformations (where an
 // assignment gets changed into a methodcall)
 protected override Exp ResolveExpAsRight(ISemanticResolver s)
 {
     // Resolve the leftside of the operator                
     Exp.ResolveExpAsLeft(ref m_oeLeft, s);
     
     
     // Event transform  actually occurs in the assignment node.
     // A.e = A.e + d --> A.add_e(d)            
     // We have to do this before we resolve the RHS of the operator (Since we
     // can't resolve events as a RHS).
     if (m_oeLeft is EventExp)
     {   
         EventExp nodeEvent = (EventExp)m_oeLeft;
         EventExpEntry e = nodeEvent.Symbol;         
         
         // Here we just do some asserts.
         BinaryExp b = this.m_expRight as BinaryExp;
         Debug.Assert(b != null, "bad formed event +=,-=");  
      
         // By now, we know we have something of the form A = B + C   
         // Make sure that A=B. Since we resolved A as left, must resolve B as left too.
         Exp eTempLeft = b.Left;
         Exp.ResolveExpAsLeft(ref eTempLeft, s);
         Debug.Assert(eTempLeft is EventExp);
         Debug.Assert(Object.ReferenceEquals(((EventExp) eTempLeft).Symbol, e)); // symbols should be exact references
         
         // Resolve C (the delegate that we're adding to the event)
         Exp eTempRight = b.Right;
         Exp.ResolveExpAsRight(ref eTempRight, s);            
         Debug.Assert(AST.DelegateDecl.IsDelegate(eTempRight.CLRType), "Event only ops w/ delegates"); // @todo -legit/            
         
         Debug.Assert(b.Op == BinaryExp.BinaryOp.cAdd || b.Op == BinaryExp.BinaryOp.cSub);
             
         
         MethodExpEntry m2 = (b.Op == BinaryExp.BinaryOp.cAdd) ? e.AddMethod : e.RemoveMethod;
             
         Exp e2 = new MethodCallExp(
             nodeEvent.InstanceExp,
             m2,
             new ArgExp[] {
                 new ArgExp(EArgFlow.cIn, eTempRight)
             },
             s
         );
                 
         Exp.ResolveExpAsRight(ref e2, s);
         return e2;            
     }
     
     Exp.ResolveExpAsRight(ref m_expRight, s);
                     
     
     // Check for calling add_, remove on events
     // a.E += X 
     // a.E = a.E + X (parser transforms)
     // if E is a delegate, and RHS is structured like E + X
     // then transform to a.add_E(X) or a.remove_E(x)
     
     // @todo - use the EventInfo to get exact add / remove functions
     if (DelegateDecl.IsDelegate(m_oeLeft.CLRType))
     {   
         // Events can only exist on a class
         AST.FieldExp f = m_oeLeft as FieldExp;
         if (f == null)
             goto NotAnEvent;
             
         Exp eInstance = f.InstanceExp; // ok if static                
         
         BinaryExp rhs = m_expRight as BinaryExp;
         if (rhs == null)
             goto NotAnEvent;            
         
         // Check if RHS is a.E + X
         if ((rhs.Left != m_oeLeft) || (rhs.Right.CLRType != rhs.Left.CLRType))
             goto NotAnEvent;
         
                     
         string stEventName = f.Symbol.Name;
         string stOpName;
         if (rhs.Op == BinaryExp.BinaryOp.cAdd)
             stOpName = "add_" + stEventName;
         else if (rhs.Op == BinaryExp.BinaryOp.cSub)
             stOpName = "remove_" + stEventName;                        
         else
             goto NotAnEvent;                
          
         // a.add_E(X);    
         Exp e = new MethodCallExp(
             eInstance,
             new Identifier(stOpName),
             new ArgExp[] {
                 new ArgExp(EArgFlow.cIn, rhs.Right)
             }
         );            
         
         Exp.ResolveExpAsRight(ref e, s);
         e.SetLocation(this.Location);    
         return e;
                     
         
     NotAnEvent:
         ;            
     }
     
     // Check for set-indexer
     if (m_oeLeft is ArrayAccessExp)
     {
         ArrayAccessExp a = m_oeLeft as ArrayAccessExp;
         if (a.IsIndexer) 
         {
             // Leftside: get_Item(idx, value);
             System.Type [] alParams = new Type [] {
                 a.ExpIndex.CLRType,
                 m_expRight.CLRType
             };
         
             TypeEntry t = s.ResolveCLRTypeToBlueType(a.Left.CLRType);            
             MethodExpEntry m = t.LookupIndexer(a.Left.Location, s, alParams, true);
             
             Exp e = new MethodCallExp(
                 a.Left,
                 m,
                 new ArgExp[] { 
                     new ArgExp(EArgFlow.cIn, a.ExpIndex),
                     new ArgExp(EArgFlow.cIn, m_expRight) 
                 },
                 s);
             
             Exp.ResolveExpAsRight(ref e, s);
             e.SetLocation(this.Location);    
             return e;
         }        
     }
     
     // Check for transforming properties into MethodCalls
     if (m_oeLeft is PropertyExp)
     {
         PropertyExp p = (PropertyExp) m_oeLeft;
         
         Exp e = new MethodCallExp(
             p.InstanceExp, 
             p.Symbol.SymbolSet, 
             new ArgExp[] { 
                 new ArgExp(EArgFlow.cIn, m_expRight) 
             },
             s);
             
         Exp.ResolveExpAsRight(ref e, s);
         e.SetLocation(this.Location);
         return e;
     }
     
     CalcCLRType(s);
 
     // Ensure type match        
     s.EnsureAssignable(m_expRight, m_oeLeft.CLRType);        
     
     return this;
 }
示例#27
0
文件: ExpAST.cs 项目: chenzuo/blue
 // Semantic resolution
 // "a X= b" is semantically equivalent to "a = a X b"
 protected override Exp ResolveExpAsRight(ISemanticResolver s)
 {
     // Note that the left side ("a") of "a X= b" is both a 
     // Left & Right side value
     ResolveExpAsLeft(ref this.m_eLeft, s);
     ResolveExpAsRight(ref this.m_expRight, s);
    
     
     CalcCLRType(s);
 
     // Ensure type match
     s.EnsureAssignable(m_expRight, Left.CLRType);
     
     return this;
 }
示例#28
0
 // Resolution
 public abstract void ResolveType(ISemanticResolver s);
示例#29
0
文件: ExpAST.cs 项目: chenzuo/blue
    protected override Exp ResolveExpAsRight(ISemanticResolver s)
    {
        for(int i = 0; i < m_eList.Length; i++)
            StatementExp.ResolveExpAsRight(ref m_eList[i], s);

        Exp.ResolveExpAsRight(ref m_eLast, s);
            
        CalcCLRType(s);
                    
        return this;
    }
示例#30
0
 public override void DebugCheck(ISemanticResolver s)
 {        
     BlueType.DebugCheck(s);        
 }
示例#31
0
文件: ExpAST.cs 项目: chenzuo/blue
 // Resolve the expression as RHS value.
 protected override Exp ResolveExpAsRight(ISemanticResolver s)
 {
     //Debug.Assert(m_eFlow == EArgFlow.cIn | m_eFlow == EArgFlow.cRef);
     Exp.ResolveExpAsRight(ref m_exp, s);
     CalcCLRType(s);
     
     return this;
 }
示例#32
0
文件: ExpAST.cs 项目: chenzuo/blue
 // Type of an assignment is the type of the Right Side    
 protected override Type CalcCLRTypeHelper(ISemanticResolver s)
 {
     return m_oeLeft.CLRType;
 }
示例#33
0
文件: ExpAST.cs 项目: chenzuo/blue
 public override void DebugCheck(ISemanticResolver s)
 {
     Debug.Assert(false);
 }
示例#34
0
 public override void DebugCheck(ISemanticResolver s)
 {
     base.DebugCheck(s);
     Debug.Assert(CLRType.IsByRef, "Ref type must wrap a ref");
     Debug.Assert(!m_tElem.BlueType.CLRType.IsByRef, "Can't have ref to ref");
 }
示例#35
0
文件: ExpAST.cs 项目: chenzuo/blue
 protected override Type CalcCLRTypeHelper(ISemanticResolver s)
 {        
     Debug.Assert(false);
     return null;
 }
示例#36
0
文件: ExpAST.cs 项目: chenzuo/blue
 protected override Type CalcCLRTypeHelper(ISemanticResolver s)
 {
     return null;
 }
示例#37
0
文件: ExpAST.cs 项目: chenzuo/blue
 public DeclareLocalStmtExp(System.Type t, ISemanticResolver s)
     : this(s.ResolveCLRTypeToBlueType(t))
 {           
 }
示例#38
0
文件: ExpAST.cs 项目: chenzuo/blue
 // Determine the CLR type of the expression
 protected override Type CalcCLRTypeHelper(ISemanticResolver s)
 {
     return typeof(char);
 }
示例#39
0
文件: ExpAST.cs 项目: chenzuo/blue
 public override void DebugCheck(ISemanticResolver s)
 {        
 }
示例#40
0
文件: ExpAST.cs 项目: chenzuo/blue
 public override void DebugCheck(ISemanticResolver s)
 {
     m_exp.DebugCheck(s);
 }
示例#41
0
 // Since we already have a symbol, we don't have anything to do
 // (symbols are resolved);
 public override void ResolveType(ISemanticResolver s)
 {   
 }
示例#42
0
 // Debugging support - Validate each symbol entry
 // Allow recursive flag so that we don't get stuck in an infinite loop
 public virtual void DebugCheck(ISemanticResolver s)
 {
 }
示例#43
0
文件: ExpAST.cs 项目: chenzuo/blue
 public override void DebugCheck(ISemanticResolver s)
 {
     foreach(Exp e in m_eList)
         e.DebugCheck(s);
     m_eLast.DebugCheck(s);
 }
示例#44
0
文件: ExpAST.cs 项目: chenzuo/blue
 // This gets called by CalcCLRType()
 // Derived classes override this and return the clr type    
 protected virtual Type CalcCLRTypeHelper(ISemanticResolver s)
 {
     // This should be implemented
     Debug.Assert(false, "@todo - impl");
     return null;
 }
示例#45
0
文件: ExpAST.cs 项目: chenzuo/blue
 public override void DebugCheck(ISemanticResolver s)
 {
     Debug.Assert(Left != null);
     Debug.Assert(Right != null);
 
     Left.DebugCheck(s);
     Right.DebugCheck(s);            
 }
示例#46
0
文件: ExpAST.cs 项目: chenzuo/blue
    // 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;
        }
        
    }
示例#47
0
文件: ExpAST.cs 项目: chenzuo/blue
 //-----------------------------------------------------------------------------
 // Debugging check
 //-----------------------------------------------------------------------------
 public override void DebugCheck(ISemanticResolver s)
 {
     Debug.Assert(m_oeLeft != null);
     Debug.Assert(m_expRight != null);
 
     m_oeLeft.DebugCheck(s);
     m_expRight.DebugCheck(s);
         
 }
示例#48
0
文件: ExpAST.cs 项目: chenzuo/blue
 //-----------------------------------------------------------------------------
 // Debugging check
 //-----------------------------------------------------------------------------
 public override void DebugCheck(ISemanticResolver s)
 {
     CalcCLRType(s);  
     m_left.DebugCheck(s);
 }
示例#49
0
文件: ExpAST.cs 项目: chenzuo/blue
 // Helper to resolve the expression as RHS value.
 // Return the newly-resolved exp node. In most cases, that will just be
 // the old node, but in a resolved state. For things like operator overloading,
 // it will be a totally different node.
 // Note that we must expose this version because 'ref Exp' is not assignable
 // with any derived expression.
 protected abstract Exp ResolveExpAsRight(ISemanticResolver s);    
示例#50
0
文件: ExpAST.cs 项目: chenzuo/blue
    // Nothing to resolve for literal expressions
    protected override Exp ResolveExpAsRight(ISemanticResolver s)
    {
        CalcCLRType(s);
#if DEBUG
        m_fResolved = true;
#endif
        return this;
    }
示例#51
0
文件: ExpAST.cs 项目: chenzuo/blue
 public override void DebugCheck(ISemanticResolver s)
 {
     Debug.Assert(Arg != null);
 
     Arg.DebugCheck(s);            
 }
示例#52
0
文件: ExpAST.cs 项目: chenzuo/blue
    public override void DebugCheck(ISemanticResolver s)
    {   
        Debug.Assert(Exp.CanBeNullType(this) || this.CLRType != null);
#if DEBUG
        Debug.Assert(m_fResolved);
#endif      
    }