C# AST.InferType方法代码示例

 internal CallableExpression(AST expression)
   : base(expression.context, ""){
   this.expression = expression;
   JSLocalField field = new JSLocalField("", null, 0, Missing.Value);
   this.expressionInferredType = expression.InferType(field);
   field.inferred_type = this.expressionInferredType;
   this.member = field;
   this.members = new MemberInfo[]{field};
 }

 internal override void SetPartialValue(AST partial_value){
   //ResolveLHValue has already been called and has already checked if the target is accessible and assignable
   if (this.members == null || this.members.Length == 0) return; //Assignment to an undeclared variable. Nothing further to do.
   if (this.member is JSLocalField){
     //If we are dealing with an assignment to an untyped local variable, we need to tell the type inferencer about the assignment
     JSLocalField lfield = (JSLocalField)this.member;
     if (lfield.type == null){
       IReflect ir = partial_value.InferType(lfield);
       if (ir == Typeob.String && partial_value is Plus)
         lfield.SetInferredType(Typeob.Object, partial_value);
       else
         lfield.SetInferredType(ir, partial_value);
       //but then we are done
       return;
     }
     lfield.isDefined = true;
   }
   Binding.AssignmentCompatible(this.InferType(null), partial_value, partial_value.InferType(null), this.isFullyResolved);
 }

      internal void SetPartialValue(ASTList argList, IReflect[] argIRs, AST partial_value, bool inBrackets){
        if (this.members == null || this.members.Length == 0){
          this.HandleNoSuchMemberError();
          this.isAssignmentToDefaultIndexedProperty = true;
          return; //Have to do a runtime lookup
        }

        this.PartiallyEvaluate(); //The rhside value of the binding delivers the object with the default indexed property we are assigning to
        IReflect ir = this.InferType(null);
        this.isAssignmentToDefaultIndexedProperty = true;
        if (ir == Typeob.Object){
          JSVariableField jsvf = this.member as JSVariableField;
          if (jsvf == null || !jsvf.IsLiteral || !(jsvf.value is ClassScope))
            return; //Not enough is known at compile time to give an error
          ir = Typeob.Type;
          goto giveError;
        }
        
        //Might be an assignment to an array element
        if ((ir is TypedArray || (ir is Type && ((Type)ir).IsArray))){
          bool gaveAnError = false;
          //Check dimension
          int n = argIRs.Length;
          int m = ir is TypedArray ? ((TypedArray)ir).rank : ((Type)ir).GetArrayRank();
          if (n != m){
            this.context.HandleError(JSError.IncorrectNumberOfIndices, this.isFullyResolved);
            gaveAnError = true;
          }
          //Check type of indices
          for (int i = 0; i < m; i++){
            if (!gaveAnError && i < n && argIRs[i] != Typeob.Object &&
                (!Convert.IsPrimitiveNumericType(argIRs[i]) || Convert.IsBadIndex(argList[i]))){
              argList[i].context.HandleError(JSError.TypeMismatch, this.isFullyResolved);       
              gaveAnError = true;
            }
          }
          this.isArrayElementAccess = true;
          this.isAssignmentToDefaultIndexedProperty = false;
          this.defaultMember = member;
          this.defaultMemberReturnIR = ir;
          
          IReflect elemIR = ir is TypedArray ? ((TypedArray)ir).elementType : ((Type)ir).GetElementType();
          Binding.AssignmentCompatible(elemIR, partial_value, partial_value.InferType(null), this.isFullyResolved);
          return;
        }
        
        MemberInfo[] defaultMembers = JSBinder.GetDefaultMembers(ir);
        if (defaultMembers != null && defaultMembers.Length > 0 && this.member != null){
          try{
            PropertyInfo prop = JSBinder.SelectProperty(defaultMembers, argIRs);
            if (prop == null){ 
              this.context.HandleError(JSError.NotIndexable, Convert.ToTypeName(ir));
              return;
            }
            if (JSProperty.GetSetMethod(prop, true) == null){
              if (ir == Typeob.String)
                this.context.HandleError(JSError.UselessAssignment);
              else
                this.context.HandleError(JSError.AssignmentToReadOnly, this.isFullyResolved&&this.Engine.doFast);
              return;
            }
            if (!Binding.CheckParameters(prop.GetIndexParameters(), argIRs, argList, this.context, 0, false, true)){
              return;
            }
            this.defaultMember = this.member;
            this.defaultMemberReturnIR = ir;
            this.members = defaultMembers;
            this.member = prop;
          }catch(AmbiguousMatchException){
            this.context.HandleError(JSError.AmbiguousMatch, this.isFullyResolved);
            this.member = null;
          }
          return;
        }
        
      giveError:
        this.member = null;
        if (!inBrackets)
          this.context.HandleError(JSError.IllegalAssignment);
        else
          this.context.HandleError(JSError.NotIndexable, Convert.ToTypeName(ir));
      }