public UnaOpSig(PredefinedType pt, UnaOpMask grfuom, int cuosSkip, PfnBindUnaOp pfn, UnaOpFuncKind fnkind)
 {
     this.pt = pt;
     this.grfuom = grfuom;
     this.cuosSkip = cuosSkip;
     this.pfn = pfn;
     this.fnkind = fnkind;
 }

        internal static AggregateSymbol InitializePredefinedType(AggregateSymbol sym, PredefinedType pt)
        {
            sym.SetPredefined(true);
            sym.SetPredefType(pt);
            sym.SetSkipUDOps(pt <= PredefinedType.PT_ENUM && pt != PredefinedType.PT_INTPTR && pt != PredefinedType.PT_UINTPTR && pt != PredefinedType.PT_TYPE);

            return sym;
        }

 public BinOpSig(PredefinedType pt1, PredefinedType pt2,
     BinOpMask mask, int cbosSkip, PfnBindBinOp pfn, OpSigFlags grfos, BinOpFuncKind fnkind)
 {
     this.pt1 = pt1;
     this.pt2 = pt2;
     this.mask = mask;
     this.cbosSkip = cbosSkip;
     this.pfn = pfn;
     this.grfos = grfos;
     this.fnkind = fnkind;
 }

        // We want to delay load the predef syms as needed.
        private AggregateSymbol DelayLoadPredefSym(PredefinedType pt)
        {
            CType type = _runtimeBinderSymbolTable.GetCTypeFromType(PredefinedTypeFacts.GetAssociatedSystemType(pt));
            AggregateSymbol sym = type.getAggregate();

            // If we failed to load this thing, we have problems.
            if (sym == null)
            {
                return null;
            }
            return PredefinedTypes.InitializePredefinedType(sym, pt);
        }

 internal PredefinedTypeInfo(PredefinedType type, Type associatedSystemType, string name, bool required, int arity, bool inMscorlib)
     : this(type, associatedSystemType, name, required, arity, AggKindEnum.Class, FUNDTYPE.FT_REF, inMscorlib)
 {
 }

 public bool isPredefAgg(PredefinedType pt)
 {
     return _isPredefined && (PredefinedType)_iPredef == pt;
 }

 private static bool CheckSingleType(PredefinedType predefinedType, IPsiModule psiModule, IType type, ITypeConversionRule conversionRule, IType typeInDeclaration)
 {
     if (!type.IsGenericOrNonIEnumerable())
     {
         if (!type.IsSubtypeOf(predefinedType.Array))
             return true;
         IDeclaredType scalarType = type.GetScalarType();
         return scalarType != null && scalarType.IsImplicitlyConvertibleTo(typeInDeclaration, conversionRule);
     }
     IDeclaredType ienumerableOf = CollectionTypeUtil.CreateIEnumerableOf(psiModule, typeInDeclaration);
     return ienumerableOf == null || type.IsImplicitlyConvertibleTo(ienumerableOf, conversionRule);
 }

 protected virtual EXPRARRINIT GenerateParamsArray(EXPR args, PredefinedType pt)
 {
     int parameterCount = ExpressionIterator.Count(args);
     AggregateType paramsArrayElementType = GetSymbolLoader().GetOptPredefTypeErr(pt, true);
     ArrayType paramsArrayType = GetSymbolLoader().GetTypeManager().GetArray(paramsArrayElementType, 1);
     EXPRCONSTANT paramsArrayArg = GetExprFactory().CreateIntegerConstant(parameterCount);
     EXPRARRINIT arrayInit = GetExprFactory().CreateArrayInit(EXPRFLAG.EXF_CANTBENULL, paramsArrayType, args, paramsArrayArg, null);
     arrayInit.dimSize = parameterCount;
     arrayInit.dimSizes = new int[] { arrayInit.dimSize }; // CLEANUP: Why isn't this done by the factory?
     return arrayInit;
 }

 private AggregateSymbol GetOptPredefAgg(PredefinedType pt)
 {
     return GetSymbolLoader().GetOptPredefAgg(pt);
 }

 public bool isPredefType(PredefinedType pt)
 {
     if (IsAggregateType())
         return AsAggregateType().getAggregate().IsPredefined() && AsAggregateType().getAggregate().GetPredefType() == pt;
     return (IsVoidType() && pt == PredefinedType.PT_VOID);
 }

 public bool TryGetPredefinedType(SyntaxToken token, out PredefinedType type)
 {
     throw new NotImplementedException();
 }

 public static bool isRequired(PredefinedType pt)
 {
     return PredefinedTypeFacts.IsRequired(pt);
 }

 public static string GetFullName(PredefinedType pt)
 {
     return PredefinedTypeFacts.GetName(pt);
 }

        public AggregateSymbol GetOptPredefAgg(PredefinedType pt)
        {
            if (_predefSyms[(int)pt] == null)
            {
                // Delay load this thing.
                _predefSyms[(int)pt] = DelayLoadPredefSym(pt);
            }

            Debug.Assert(_predefSyms != null);
            return _predefSyms[(int)pt];
        }

 public AggregateSymbol GetReqPredefAgg(PredefinedType pt)
 {
     if (!PredefinedTypeFacts.IsRequired(pt)) throw Error.InternalCompilerError();
     if (_predefSyms[(int)pt] == null)
     {
         // Delay load this thing.
         _predefSyms[(int)pt] = DelayLoadPredefSym(pt);
     }
     return _predefSyms[(int)pt];
 }

        public void ReportMissingPredefTypeError(ErrorHandling errorContext, PredefinedType pt)
        {
            Debug.Assert(_pBSymmgr != null);
            Debug.Assert(_predefSyms != null);
            Debug.Assert((PredefinedType)0 <= pt && pt < PredefinedType.PT_COUNT && _predefSyms[(int)pt] == null);

            // We do not assert that !predefTypeInfo[pt].isRequired because if the user is defining
            // their own MSCorLib and is defining a required PredefType, they'll run into this error
            // and we need to allow it to go through.

            errorContext.Error(ErrorCode.ERR_PredefinedTypeNotFound, PredefinedTypeFacts.GetName(pt));
        }

 public bool TryGetPredefinedType(SyntaxToken token, out PredefinedType type)
 {
     type = GetPredefinedType(token);
     return type != PredefinedType.None;
 }

 internal static string GetName(PredefinedType type)
 {
     return s_pdTypes[(int)type].name;
 }

 public void SetPredefType(PredefinedType predef)
 {
     _iPredef = predef;
 }

 public bool IsPredefinedType(SyntaxToken token, PredefinedType type)
 {
     PredefinedType actualType;
     return TryGetPredefinedType(token, out actualType) && actualType == type;
 }