//------------------------------------------------------------ // MethPropWithInst Constructor (2) // /// <summary></summary> /// <param name="mps"></param> /// <param name="ats"></param> /// <param name="TypeArguments"></param> //------------------------------------------------------------ internal MethPropWithInst( METHPROPSYM mps, AGGTYPESYM ats, TypeArray TypeArguments) // = NULL) { Set(mps, ats, TypeArguments); }
//------------------------------------------------------------ // SymWithType.CreateCorrespondingInstance (static) // /// <summary> /// /// </summary> /// <param name="sym"></param> /// <param name="ats"></param> /// <returns></returns> //------------------------------------------------------------ static internal SymWithType CreateCorrespondingInstance(SYM sym, AGGTYPESYM ats) { if (sym == null) { return(new SymWithType()); } SymWithType swt = null; switch (sym.Kind) { case SYMKIND.METHSYM: return(new MethWithType(sym as METHSYM, ats) as SymWithType); case SYMKIND.PROPSYM: return(new PropWithType(sym as PROPSYM, ats) as SymWithType); case SYMKIND.EVENTSYM: return(new EventWithType(sym as EVENTSYM, ats) as SymWithType); case SYMKIND.MEMBVARSYM: return(new FieldWithType(sym as MEMBVARSYM, ats) as SymWithType); default: break; } return(new SymWithType(sym, ats)); }
//------------------------------------------------------------ // FUNCBREC.BindNubValue // /// <summary> /// Create an expr for exprSrc.Value where exprSrc->type is a NUBSYM. /// </summary> /// <param name="treeNode"></param> /// <param name="srcExpr"></param> /// <returns></returns> //------------------------------------------------------------ private EXPR BindNubValue(BASENODE treeNode, EXPR srcExpr) { DebugUtil.Assert(srcExpr != null && srcExpr.TypeSym.IsNUBSYM); // For new T?(x), the answer is x. if (IsNubCtor(srcExpr)) { DebugUtil.Assert( (srcExpr as EXPRCALL).ArgumentsExpr != null && (srcExpr as EXPRCALL).ArgumentsExpr.Kind != EXPRKIND.LIST); return((srcExpr as EXPRCALL).ArgumentsExpr); } TYPESYM baseTypeSym = (srcExpr.TypeSym as NUBSYM).BaseTypeSym; AGGTYPESYM ats = (srcExpr.TypeSym as NUBSYM).GetAggTypeSym(); if (ats == null) { return(NewError(treeNode, baseTypeSym)); } compiler.EnsureState(ats, AggStateEnum.Prepared); PROPSYM propertySym = compiler.MainSymbolManager.NullableValuePropertySym; if (propertySym == null) { string name = compiler.NameManager.GetPredefinedName(PREDEFNAME.CAP_VALUE); propertySym = compiler.MainSymbolManager.LookupAggMember( name, ats.GetAggregate(), SYMBMASK.PROPSYM) as PROPSYM; if (propertySym == null || propertySym.IsStatic || propertySym.Access != ACCESS.PUBLIC || propertySym.ParameterTypes.Count > 0 || !propertySym.ReturnTypeSym.IsTYVARSYM || propertySym.GetMethodSym == null) { compiler.Error( treeNode, CSCERRID.ERR_MissingPredefinedMember, new ErrArg(ats), new ErrArg(name)); return(NewError(treeNode, baseTypeSym)); } compiler.MainSymbolManager.NullableValuePropertySym = propertySym; } CheckFieldUse(srcExpr, true); EXPRPROP propertyExpr = NewExpr(treeNode, EXPRKIND.PROP, baseTypeSym) as EXPRPROP; propertyExpr.SlotPropWithType.Set(propertySym, ats); propertyExpr.GetMethodWithType.Set(propertySym.GetMethodSym, ats); propertyExpr.ArgumentsExpr = null; propertyExpr.ObjectExpr = srcExpr; return(propertyExpr); }
//------------------------------------------------------------ // MethWithInst Constructor (2) // /// <summary></summary> /// <param name="meth"></param> /// <param name="ats"></param> /// <param name="typeArgs"></param> //------------------------------------------------------------ internal MethWithInst( METHSYM meth, AGGTYPESYM ats, TypeArray typeArgs) // = NULL) { Set(meth, ats, typeArgs); }
//------------------------------------------------------------ // FUNCBREC.GetActionInvokeMethod // /// <summary></summary> /// <param name="arity"></param> /// <returns></returns> //------------------------------------------------------------ internal METHSYM GetActionInvokeMethod(int arity) { if (arity < 0 || arity >= systemActionDelegateCount) { return(null); } InitSystemActionInvokeMethodSyms(); METHSYM invokeSym = systemActionInvokeMethodSyms[arity]; if (invokeSym != null) { return(invokeSym); } AGGTYPESYM actionAts = GetActionTypeSym(arity); if (actionAts == null) { return(null); } invokeSym = Compiler.MainSymbolManager.LookupAggMember( "Invoke", actionAts.GetAggregate(), SYMBMASK.METHSYM) as METHSYM; systemActionInvokeMethodSyms[arity] = invokeSym; return(invokeSym); }
//------------------------------------------------------------ // ReflectionUtil.GetConstructedMethodInfo2 (obsolete) // /// <summary></summary> /// <param name="methInfo"></param> /// <param name="aggTypeSym"></param> /// <param name="methTypeArguments"></param> /// <returns></returns> //------------------------------------------------------------ internal static MethodInfo GetConstructedMethodInfo2( MethodInfo methInfo, AGGTYPESYM aggTypeSym, TypeArray methTypeArguments) { DebugUtil.Assert(methInfo != null); bool isGenericType = false; Type type = null; MethodInfo methInfo2 = null; if (aggTypeSym != null) { type = aggTypeSym.GetConstructedType(null, null, false); if (type != null && type.IsGenericType) { isGenericType = true; } } if (!methInfo.IsGenericMethod && !isGenericType) { return(methInfo); } if (isGenericType) { string name = methInfo.Name; Type[] paramTypes = SubstParameterTypes( methInfo.GetParameters(), type.GetGenericArguments()); try { methInfo2 = type.GetMethod( name, paramTypes); } catch (NotSupportedException) { methInfo2 = System.Reflection.Emit.TypeBuilder.GetMethod( type, methInfo); } } else { methInfo2 = methInfo; } if (methInfo.IsGenericMethod) { throw new NotImplementedException(""); } return(methInfo2); }
//------------------------------------------------------------ // FUNCBREC.BindNubNew // /// <summary> /// Create an expr for new T?(exprSrc) where T is exprSrc->type. /// </summary> /// <param name="treeNode"></param> /// <param name="srcExpr"></param> /// <returns></returns> //------------------------------------------------------------ private EXPR BindNubNew(BASENODE treeNode, EXPR srcExpr) { DebugUtil.Assert(srcExpr != null); // Create a NUBSYM instance whose base bype is represented by srcExpr.TypeSym. NUBSYM nubSym = Compiler.MainSymbolManager.GetNubType(srcExpr.TypeSym); // Get a TYPESYM instance representing Nullable<> for nubSym. AGGTYPESYM aggTypeSym = nubSym.GetAggTypeSym(); if (aggTypeSym == null) { return(NewError(treeNode, nubSym)); } Compiler.EnsureState(aggTypeSym, AggStateEnum.Prepared); METHSYM methSym = Compiler.MainSymbolManager.NullableCtorMethodSym; if (methSym == null) { string name = Compiler.NameManager.GetPredefinedName(PREDEFNAME.CTOR); for (SYM sym = Compiler.MainSymbolManager.LookupAggMember(name, aggTypeSym.GetAggregate(), SYMBMASK.ALL); ; sym = sym.NextSameNameSym) { if (sym == null) { Compiler.Error(treeNode, CSCERRID.ERR_MissingPredefinedMember, new ErrArg(aggTypeSym), new ErrArg(name)); return(NewError(treeNode, nubSym)); } if (sym.IsMETHSYM) { methSym = sym as METHSYM; if (methSym.ParameterTypes.Count == 1 && methSym.ParameterTypes[0].IsTYVARSYM && methSym.Access == ACCESS.PUBLIC) { break; } } } Compiler.MainSymbolManager.NullableCtorMethodSym = methSym; } EXPRCALL resExpr = NewExpr(treeNode, EXPRKIND.CALL, nubSym) as EXPRCALL; resExpr.MethodWithInst.Set(methSym, aggTypeSym, BSYMMGR.EmptyTypeArray); resExpr.ArgumentsExpr = srcExpr; resExpr.ObjectExpr = null; resExpr.Flags |= EXPRFLAG.NEWOBJCALL | EXPRFLAG.CANTBENULL; return(resExpr); }
//------------------------------------------------------------ // SymWithType.Set (1) // /// <summary> /// <para>If sym is null, ats is set null.</para> /// <para>If sym is not null, sym and ats should have the same parent.</para> /// </summary> /// <param name="sym"></param> /// <param name="ats"></param> //------------------------------------------------------------ internal void Set(SYM sym, AGGTYPESYM ats) { if (sym == null) { ats = null; } DebugUtil.Assert(ats == null || sym.ParentSym == ats.GetAggregate()); if (ats != null && sym.ParentSym != ats.GetAggregate()) { return; } this.Sym = sym; this.AggTypeSym = ats; }
//------------------------------------------------------------ // FUNCBREC.BindNubGetValOrDef // /// <summary> /// Create an expr for exprSrc.GetValueOrDefault() /// where exprSrc->type is a NUBSYM. /// </summary> /// <param name="treeNode"></param> /// <param name="srcExpr"></param> /// <returns></returns> //------------------------------------------------------------ private EXPR BindNubGetValOrDef(BASENODE treeNode, EXPR srcExpr) { DebugUtil.Assert(srcExpr != null && srcExpr.TypeSym.IsNUBSYM); TYPESYM baseTypeSym = (srcExpr.TypeSym as NUBSYM).BaseTypeSym; // If srcExpr is null, just return the appropriate default value. if (srcExpr.GetConst() != null) { return(AddSideEffects(treeNode, NewExprZero(treeNode, baseTypeSym), srcExpr, true, true)); } // For new T?(x), the answer is x. if (IsNubCtor(srcExpr)) { DebugUtil.Assert( (srcExpr as EXPRCALL).ArgumentsExpr != null && (srcExpr as EXPRCALL).ArgumentsExpr.Kind != EXPRKIND.LIST); return((srcExpr as EXPRCALL).ArgumentsExpr); } AGGTYPESYM aggTypeSym = (srcExpr.TypeSym as NUBSYM).GetAggTypeSym(); if (aggTypeSym == null) { return(NewError(treeNode, baseTypeSym)); } Compiler.EnsureState(aggTypeSym, AggStateEnum.Prepared); METHSYM methSym = EnsureNubGetValOrDef(treeNode); if (methSym == null) { return(NewError(treeNode, baseTypeSym)); } CheckFieldUse(srcExpr, true); EXPRCALL resExpr = NewExpr(treeNode, EXPRKIND.CALL, baseTypeSym) as EXPRCALL; resExpr.MethodWithInst.Set(methSym, aggTypeSym, BSYMMGR.EmptyTypeArray); resExpr.ArgumentsExpr = null; resExpr.ObjectExpr = srcExpr; return(resExpr); }
//------------------------------------------------------------ // CLSDREC.DefineExtensionMethodCore // /// <summary></summary> /// <param name="methodSym"></param> //------------------------------------------------------------ internal void DefineExtensionMethodCore(METHSYM methodSym) { DebugUtil.Assert(methodSym != null); DebugUtil.Assert(methodSym.ParameterTypes.Count > 0); TypeArray paramTypes = methodSym.ParameterTypes; AGGTYPESYM ats = paramTypes[0] as AGGTYPESYM; if (ats == null) { return; } AGGSYM targetAggSym = ats.GetAggregate(); METHSYM instanceMethSym = Compiler.MainSymbolManager.CreateGlobalSym( SYMKIND.METHSYM, methodSym.Name, targetAggSym) as METHSYM; instanceMethSym.ContainingAggDeclSym = targetAggSym.FirstDeclSym; instanceMethSym.IsUnsafe = methodSym.IsUnsafe; instanceMethSym.TypeVariables = methodSym.TypeVariables; TypeArray instParamTypes = new TypeArray(); for (int i = 1; i < paramTypes.Count; ++i) { instParamTypes.Add(paramTypes[i]); } instanceMethSym.ParameterTypes = Compiler.MainSymbolManager.AllocParams(instParamTypes); instanceMethSym.ReturnTypeSym = methodSym.ReturnTypeSym; instanceMethSym.Access = methodSym.Access; instanceMethSym.IsStatic = false; instanceMethSym.IsParameterArray = methodSym.IsParameterArray; instanceMethSym.IsVarargs = methodSym.IsVarargs; instanceMethSym.StaticExtensionMethodSym = methodSym; }
//------------------------------------------------------------ // FUNCBREC.CreateAutoImplementedGetAccessor // /// <summary></summary> /// <param name="methodSym"></param> /// <returns></returns> //------------------------------------------------------------ internal EXPR CreateAutoImplementedGetAccessor(METHSYM methodSym) { CreateNewScope(); SCOPESYM scopeSym = this.currentScopeSym; this.currentScopeSym.ScopeFlags = SCOPEFLAGS.NONE; this.currentBlockExpr = NewExprBlock(treeNode); this.currentBlockExpr.ScopeSym = this.currentScopeSym; SymWithType symWithType = new SymWithType(); AGGTYPESYM parentAts = methodSym.ParentAggSym.GetThisType(); symWithType.Set( methodSym.PropertySym.BackFieldSym, parentAts); EXPR fieldExpr = BindToField( null, BindThisImplicit(null), FieldWithType.Convert(symWithType), BindFlagsEnum.RValueRequired); //TYPESYM retTypeSym = methodSym.ReturnTypeSym; EXPRRETURN returnExpr = NewExpr(null, EXPRKIND.RETURN, null) as EXPRRETURN; returnExpr.ObjectExpr = fieldExpr; this.currentBlockExpr.StatementsExpr = returnExpr; EXPRBLOCK blockExpr = this.currentBlockExpr; this.currentBlockExpr = blockExpr.OwingBlockExpr; CloseScope(); CorrectAnonMethScope(blockExpr.ScopeSym); return(blockExpr); }
//------------------------------------------------------------ // ReflectionUtil.GetConstructedFieldInfo // /// <summary></summary> /// <param name="compiler"></param> /// <param name="fieldSym"></param> /// <param name="aggTypeSym"></param> /// <returns></returns> //------------------------------------------------------------ internal static FieldInfo GetConstructedFieldInfo( COMPILER compiler, MEMBVARSYM fieldSym, AGGTYPESYM aggTypeSym) { DebugUtil.Assert(compiler != null && compiler.Emitter != null); EMITTER emitter = compiler.Emitter; DebugUtil.Assert(emitter != null && fieldSym != null && aggTypeSym != null); SymUtil.EmitParentSym(emitter, aggTypeSym); SymUtil.GetSystemTypeFromSym(aggTypeSym, null, null); emitter.EmitMembVarDef(fieldSym); Type parentType = aggTypeSym.Type; FieldInfo fieldDefInfo = fieldSym.FieldInfo; Exception ex = null; if (!parentType.IsGenericType) { return(fieldDefInfo); } FieldInfo cstrFieldInfo = null; try { cstrFieldInfo = parentType.GetField(fieldDefInfo.Name); } catch (NotSupportedException) { cstrFieldInfo = ReflectionUtil.GetFieldInfo( parentType, fieldDefInfo, out ex); } return(cstrFieldInfo); }
//------------------------------------------------------------ // MethPropWithInst.Set (1) // /// <summary></summary> /// <param name="mps"></param> /// <param name="ats"></param> /// <param name="TypeArguments"></param> //------------------------------------------------------------ internal void Set(METHPROPSYM mps, AGGTYPESYM ats, TypeArray TypeArguments) { if (mps == null) { ats = null; TypeArguments = null; } DebugUtil.Assert( ats == null || mps != null && mps.ClassSym == ats.GetAggregate()); DebugUtil.Assert( TypeArguments == null || TypeArguments.Count == 0 || mps != null && mps.IsMETHSYM); DebugUtil.Assert( TypeArguments == null || !mps.IsMETHSYM || (mps as METHSYM).TypeVariables.Count == TypeArguments.Count); this.Sym = mps; this.AggTypeSym = ats; this.TypeArguments = TypeArguments; }
//------------------------------------------------------------ // FieldWithType Constructor (2) // /// <summary></summary> /// <param name="field"></param> /// <param name="ats"></param> //------------------------------------------------------------ internal FieldWithType(MEMBVARSYM field, AGGTYPESYM ats) { Set(field, ats); }
//------------------------------------------------------------ // FieldWithType.Set (1) // /// <summary></summary> /// <param name="field"></param> /// <param name="ats"></param> //------------------------------------------------------------ internal void Set(MEMBVARSYM field, AGGTYPESYM ats) { base.Set(field, ats); }
//------------------------------------------------------------ // EventWithType Constructor (2) // /// <summary></summary> /// <param name="evt"></param> /// <param name="ats"></param> //------------------------------------------------------------ internal EventWithType(EVENTSYM evt, AGGTYPESYM ats) { Set(evt, ats); }
//------------------------------------------------------------ // EventWithType.Set (1) // /// <summary></summary> /// <param name="evt"></param> /// <param name="ats"></param> //------------------------------------------------------------ internal void Set(EVENTSYM evt, AGGTYPESYM ats) { base.Set(evt, ats); }
//------------------------------------------------------------ // PropWithType Constructor (2) // /// <summary></summary> /// <param name="prop"></param> /// <param name="ats"></param> //------------------------------------------------------------ internal PropWithType(PROPSYM prop, AGGTYPESYM ats) { Set(prop, ats); }
//------------------------------------------------------------ // PropWithType.Set (1) // /// <summary></summary> /// <param name="prop"></param> /// <param name="ats"></param> //------------------------------------------------------------ internal void Set(PROPSYM prop, AGGTYPESYM ats) { base.Set(prop, ats); }
//------------------------------------------------------------ // MethWithType Constructor (2) // /// <summary></summary> /// <param name="meth"></param> /// <param name="ats"></param> //------------------------------------------------------------ internal MethWithType(METHSYM meth, AGGTYPESYM ats) { Set(meth, ats); }
//------------------------------------------------------------ // SymWithType Constructor (2) // /// <summary></summary> /// <param name="sym"></param> /// <param name="ats"></param> //------------------------------------------------------------ internal SymWithType(SYM sym, AGGTYPESYM ats) { Set(sym, ats); }
//------------------------------------------------------------ // MethPropWithType Constructor (2) // /// <summary></summary> /// <param name="mps"></param> /// <param name="ats"></param> //------------------------------------------------------------ internal MethPropWithType(METHPROPSYM mps, AGGTYPESYM ats) { Set(mps, ats); }
//------------------------------------------------------------ // MethPropWithType.Set (1) // /// <summary></summary /// <param name="mps"></param> /// <param name="ats"></param> //------------------------------------------------------------ internal void Set(METHPROPSYM mps, AGGTYPESYM ats) { base.Set(mps, ats); }
//------------------------------------------------------------ // ReflectionUtil.GetConstructedConstructorInfo // /// <summary></summary> /// <param name="compiler"></param> /// <param name="methodSym"></param> /// <param name="aggTypeSym"></param> /// <returns></returns> //------------------------------------------------------------ internal static ConstructorInfo GetConstructedConstructorInfo( COMPILER compiler, METHSYM methodSym, AGGTYPESYM aggTypeSym) { DebugUtil.Assert(compiler != null && compiler.Emitter != null); EMITTER emitter = compiler.Emitter; DebugUtil.Assert(emitter != null && methodSym != null && aggTypeSym != null); SymUtil.EmitParentSym(emitter, aggTypeSym); SymUtil.GetSystemTypeFromSym(aggTypeSym, null, null); emitter.EmitMethodDef(methodSym); Type parentType = aggTypeSym.Type; ConstructorInfo cnstrDefInfo = methodSym.ConstructorInfo; DebugUtil.Assert(cnstrDefInfo != null); bool isGenericType = parentType.IsGenericType; //-------------------------------------------------------- // (1) Non-generic Type //-------------------------------------------------------- if (!isGenericType) { return(cnstrDefInfo); } //-------------------------------------------------------- // (2) Generic Type //-------------------------------------------------------- TypeArray paramTypeArray = methodSym.ParameterTypes; TypeArray paramTypeArray2 = null; Type[] paramTypes = null; if (paramTypeArray != null && paramTypeArray.Count > 0) { paramTypeArray2 = compiler.MainSymbolManager.SubstTypeArray( paramTypeArray, aggTypeSym.AllTypeArguments, null, SubstTypeFlagsEnum.NormNone); paramTypes = SymUtil.GetSystemTypesFromTypeArray( paramTypeArray2, methodSym.ClassSym, methodSym); } else { paramTypes = Type.EmptyTypes; } ConstructorInfo constructedInfo = null; Exception ex = null; try { constructedInfo = parentType.GetConstructor(paramTypes); } catch (NotSupportedException) { constructedInfo = GetConstructorInfo(parentType, cnstrDefInfo, out ex); } return(constructedInfo); }
//------------------------------------------------------------ // ReflectionUtil.GetConstructedMethodInfo // /// <summary></summary> /// <param name="compiler"></param> /// <param name="methodSym"></param> /// <param name="aggTypeSym"></param> /// <param name="methTypeArguments"></param> /// <returns></returns> //------------------------------------------------------------ internal static MethodInfo GetConstructedMethodInfo( COMPILER compiler, METHSYM methodSym, AGGTYPESYM aggTypeSym, TypeArray methTypeArguments) { DebugUtil.Assert(compiler != null && compiler.Emitter != null); EMITTER emitter = compiler.Emitter; DebugUtil.Assert(emitter != null && methodSym != null && aggTypeSym != null); SymUtil.EmitParentSym(emitter, aggTypeSym); SymUtil.GetSystemTypeFromSym(aggTypeSym, null, null); emitter.EmitMethodDef(methodSym); Type parentType = aggTypeSym.Type; MethodInfo methodDefInfo = methodSym.MethodInfo; bool isGenericType = parentType.IsGenericType; bool isGenericMethod = methodDefInfo.IsGenericMethod; //-------------------------------------------------------- // (1-1) Non-generic Type, non-generic method //-------------------------------------------------------- if (!isGenericType && !isGenericMethod) { return(methodDefInfo); } //-------------------------------------------------------- // Parameter types //-------------------------------------------------------- TypeArray paramTypeArray = methodSym.ParameterTypes; TypeArray paramTypeArray2 = null; Type[] paramTypes = null; if (paramTypeArray != null && paramTypeArray.Count > 0) { paramTypeArray2 = compiler.MainSymbolManager.SubstTypeArray( paramTypeArray, aggTypeSym.AllTypeArguments, methTypeArguments, SubstTypeFlagsEnum.NormNone); paramTypes = SymUtil.GetSystemTypesFromTypeArray( paramTypeArray2, methodSym.ClassSym, methodSym); } else { paramTypes = Type.EmptyTypes; } //-------------------------------------------------------- // (1-2) Non-generic Type, generic method //-------------------------------------------------------- if (!isGenericType) { DebugUtil.Assert(methTypeArguments != null); Exception ex = null; Type[] typeArgs = SymUtil.GetSystemTypesFromTypeArray( methTypeArguments, methodSym.ClassSym, methodSym); return(ReflectionUtil.GetGenericMethod( methodDefInfo, typeArgs, out ex)); } //-------------------------------------------------------- // (2) Generic Type //-------------------------------------------------------- else { string methodName = methodDefInfo.Name; MethodInfo cstrMethInfo = null; Exception ex = null; try { cstrMethInfo = parentType.GetMethod(methodName, paramTypes); } catch (NotSupportedException) { cstrMethInfo = GetMethodInfo(parentType, methodDefInfo, out ex); } if (!isGenericMethod) { return(cstrMethInfo); } DebugUtil.Assert(methTypeArguments != null); Type[] typeArgs = SymUtil.GetSystemTypesFromTypeArray( methTypeArguments, methodSym.ClassSym, methodSym); return(ReflectionUtil.GetGenericMethod( cstrMethInfo, typeArgs, out ex)); } }
//------------------------------------------------------------ // MetaDataHelper.GetExplicitImplTypeName // /// <summary></summary> /// <param name="typeSym"></param> /// <param name="strBuilder"></param> //------------------------------------------------------------ public void GetExplicitImplTypeName(TYPESYM typeSym, StringBuilder strBuilder) { #if DEBUG if (!(typeSym != null)) { ; } #endif DebugUtil.Assert(typeSym != null); TYPESYM nakedTypeSym = typeSym.GetNakedType(false); TypeArray typeArgs = null; switch (nakedTypeSym.Kind) { default: DebugUtil.Assert(false, "Unhandled type in GetExplicitImplTypeName"); return; case SYMKIND.TYVARSYM: strBuilder.Append(nakedTypeSym.Name); break; case SYMKIND.NUBSYM: nakedTypeSym = (nakedTypeSym as NUBSYM).GetAggTypeSym(); if (nakedTypeSym == null) { DebugUtil.Assert(false, "Why did GetAts return null?"); return; } // Fall through. goto case SYMKIND.AGGTYPESYM; case SYMKIND.AGGTYPESYM: { AGGTYPESYM outerAggTypeSym = (nakedTypeSym as AGGTYPESYM).OuterTypeSym; AGGSYM aggSym = nakedTypeSym.GetAggregate(); if (outerAggTypeSym != null) { GetExplicitImplTypeName(outerAggTypeSym, strBuilder); strBuilder.Append('.'); } else { DebugUtil.Assert(aggSym.ParentBagSym != null && !aggSym.ParentBagSym.IsAGGSYM); int cch = strBuilder.Length; GetFullName(aggSym.ParentBagSym, strBuilder, aggSym); if (cch < strBuilder.Length) { strBuilder.Append('.'); } } strBuilder.Append(aggSym.Name); typeArgs = (nakedTypeSym as AGGTYPESYM).TypeArguments; } break; case SYMKIND.ERRORSYM: { ERRORSYM errSym = nakedTypeSym as ERRORSYM; SYM parentSym = errSym.ParentSym; if (parentSym != null && parentSym.IsTYPESYM) { GetExplicitImplTypeName(parentSym as TYPESYM, strBuilder); strBuilder.Append('.'); } else if (parentSym != null && parentSym.IsNSAIDSYM) { parentSym = (parentSym as NSAIDSYM).NamespaceSym; int cch = strBuilder.Length; GetFullName(parentSym, strBuilder, errSym); if (cch < strBuilder.Length) { strBuilder.Append('.'); } } strBuilder.Append(errSym.ErrorName); typeArgs = errSym.TypeArguments; } break; } if (typeArgs != null && typeArgs.Count > 0) { strBuilder.Append('<'); for (int i = 0; i < typeArgs.Count; ++i) { if (i > 0) { strBuilder.Append(','); } GetExplicitImplTypeName(typeArgs[i], strBuilder); } strBuilder.Append('>'); } // Add ptr and array modifiers AddTypeModifiers(typeSym, strBuilder); }
//------------------------------------------------------------ // ReflectionUtil.IsTypeBuilderInstruction // /// <summary></summary> /// <param name="typeSym"></param> /// <returns></returns> //------------------------------------------------------------ internal static bool IsTypeBuilderInstruction(TYPESYM typeSym) { if (typeSym == null) { return(false); } Type type = null; int count = 0; int index = 0; switch (typeSym.Kind) { //---------------------------------------------------- // AGGTYPESYM //---------------------------------------------------- case SYMKIND.AGGTYPESYM: AGGTYPESYM ats = typeSym as AGGTYPESYM; DebugUtil.Assert(ats != null); if (ats.AllTypeArguments == null || ats.AllTypeArguments.Count == 0) { return(false); } AGGSYM aggSym = ats.GetAggregate(); DebugUtil.Assert(aggSym != null); if (aggSym.TypeBuilder != null) { return(true); } TypeArray typeArgs = ats.AllTypeArguments; for (int i = 0; i < typeArgs.Count; ++i) { if (IsTypeBuilderInstruction(typeArgs[i])) { return(true); } } return(false); //---------------------------------------------------- // ARRAYSYM //---------------------------------------------------- case SYMKIND.ARRAYSYM: return(IsTypeBuilderInstruction(typeSym.ParentSym as TYPESYM)); //---------------------------------------------------- // VOIDSYM //---------------------------------------------------- case SYMKIND.VOIDSYM: return(false); //---------------------------------------------------- // PARAMMODSYM //---------------------------------------------------- case SYMKIND.PARAMMODSYM: return(IsTypeBuilderInstruction(typeSym.ParentSym as TYPESYM)); //---------------------------------------------------- // TYVARSYM //---------------------------------------------------- case SYMKIND.TYVARSYM: return(true); //---------------------------------------------------- // PTRSYM //---------------------------------------------------- case SYMKIND.PTRSYM: return(IsTypeBuilderInstruction((typeSym as PTRSYM).BaseTypeSym)); //---------------------------------------------------- // NUBSYM //---------------------------------------------------- case SYMKIND.NUBSYM: return(IsTypeBuilderInstruction((typeSym as NUBSYM).BaseTypeSym)); //---------------------------------------------------- // otherwise //---------------------------------------------------- case SYMKIND.NULLSYM: case SYMKIND.ERRORSYM: break; case SYMKIND.MODOPTTYPESYM: throw new NotImplementedException("SymbolUtil.MakeSystemType: MODOPTTYPESYM"); case SYMKIND.ANONMETHSYM: case SYMKIND.METHGRPSYM: case SYMKIND.UNITSYM: break; default: break; } return(false); }
//------------------------------------------------------------ // MethWithType.Set (1) // /// <summary></summary> /// <param name="meth"></param> /// <param name="ats"></param> //------------------------------------------------------------ internal void Set(METHSYM meth, AGGTYPESYM ats) { base.Set(meth, ats); }
//------------------------------------------------------------ // SymWithType.Clear // /// <summary></summary> //------------------------------------------------------------ internal void Clear() { Sym = null; AggTypeSym = null; }
//------------------------------------------------------------ // MethWithInst.Set (1) // /// <summary></summary> /// <param name="meth"></param> /// <param name="ats"></param> /// <param name="typeArgs"></param> //------------------------------------------------------------ internal void Set(METHSYM meth, AGGTYPESYM ats, TypeArray typeArgs) { base.Set(meth, ats, typeArgs); }