public static string GetNiceName(AggregateSymbol type)
{
if (type.IsPredefined())
return GetNiceName(type.GetPredefType());
else
return null;
}
private AggCastResult bindExplicitConversionBetweenSimpleTypes(AggregateType aggTypeDest)
{
// 13.2.1
//
// Because the explicit conversions include all implicit and explicit numeric conversions,
// it is always possible to convert from any numeric-type to any other numeric-type using
// a cast expression (14.6.6).
Debug.Assert(typeSrc != null);
Debug.Assert(aggTypeDest != null);
if (!typeSrc.isSimpleType() || !aggTypeDest.isSimpleType())
{
return(AggCastResult.Failure);
}
AggregateSymbol aggDest = aggTypeDest.getAggregate();
Debug.Assert(typeSrc.isPredefined() && aggDest.IsPredefined());
PredefinedType ptSrc = typeSrc.getPredefType();
PredefinedType ptDest = aggDest.GetPredefType();
Debug.Assert((int)ptSrc < NUM_SIMPLE_TYPES && (int)ptDest < NUM_SIMPLE_TYPES);
ConvKind convertKind = GetConvKind(ptSrc, ptDest);
// Identity and implicit conversions should already have been handled.
Debug.Assert(convertKind != ConvKind.Implicit);
Debug.Assert(convertKind != ConvKind.Identity);
if (convertKind != ConvKind.Explicit)
{
return(AggCastResult.Failure);
}
if (exprSrc.GetConst() != null)
{
// Fold the constant cast if possible.
ConstCastResult result = binder.bindConstantCast(exprSrc, exprTypeDest, needsExprDest, out exprDest, true);
if (result == ConstCastResult.Success)
{
return(AggCastResult.Success); // else, don't fold and use a regular cast, below.
}
if (result == ConstCastResult.CheckFailure && 0 == (flags & CONVERTTYPE.CHECKOVERFLOW))
{
return(AggCastResult.Abort);
}
}
bool bConversionOk = true;
if (needsExprDest)
{
// Explicit conversions involving decimals are bound as user-defined conversions.
if (isUserDefinedConversion(ptSrc, ptDest))
{
// According the language, this is a standard conversion, but it is implemented
// through a user-defined conversion. Because it's a standard conversion, we don't
// test the CONVERTTYPE.NOUDC flag here.
bConversionOk = binder.bindUserDefinedConversion(exprSrc, typeSrc, aggTypeDest, needsExprDest, out exprDest, false);
}
else
{
binder.bindSimpleCast(exprSrc, exprTypeDest, out exprDest, (flags & CONVERTTYPE.CHECKOVERFLOW) != 0 ? EXPRFLAG.EXF_CHECKOVERFLOW : 0);
}
}
return(bConversionOk ? AggCastResult.Success : AggCastResult.Failure);
}
private bool bindImplicitConversionBetweenSimpleTypes(AggregateType aggTypeSrc)
{
AggregateSymbol aggSrc = aggTypeSrc.getAggregate();
Debug.Assert(aggSrc.getThisType().isSimpleType());
Debug.Assert(_typeDest.isSimpleType());
Debug.Assert(aggSrc.IsPredefined() && _typeDest.isPredefined());
PredefinedType ptSrc = aggSrc.GetPredefType();
PredefinedType ptDest = _typeDest.getPredefType();
ConvKind convertKind;
bool fConstShrinkCast = false;
Debug.Assert((int)ptSrc < NUM_SIMPLE_TYPES && (int)ptDest < NUM_SIMPLE_TYPES);
// 13.1.7 Implicit constant expression conversions
//
// An implicit constant expression conversion permits the following conversions:
// * A constant-expression (14.16) of type int can be converted to type sbyte, byte, short,
// ushort, uint, or ulong, provided the value of the constant-expression is within the range
// of the destination type.
// * A constant-expression of type long can be converted to type ulong, provided the value of
// the constant-expression is not negative.
// Note: Don't use GetConst here since the conversion only applies to bona-fide compile time constants.
if (_exprSrc != null && _exprSrc.isCONSTANT_OK() &&
((ptSrc == PredefinedType.PT_INT && ptDest != PredefinedType.PT_BOOL && ptDest != PredefinedType.PT_CHAR) ||
(ptSrc == PredefinedType.PT_LONG && ptDest == PredefinedType.PT_ULONG)) &&
isConstantInRange(_exprSrc.asCONSTANT(), _typeDest))
{
// Special case (CLR 6.1.6): if integral constant is in range, the conversion is a legal implicit conversion.
convertKind = ConvKind.Implicit;
fConstShrinkCast = _needsExprDest && (GetConvKind(ptSrc, ptDest) != ConvKind.Implicit);
}
else if (ptSrc == ptDest)
{
// Special case: precision limiting casts to float or double
Debug.Assert(ptSrc == PredefinedType.PT_FLOAT || ptSrc == PredefinedType.PT_DOUBLE);
Debug.Assert(0 != (_flags & CONVERTTYPE.ISEXPLICIT));
convertKind = ConvKind.Implicit;
}
else
{
convertKind = GetConvKind(ptSrc, ptDest);
Debug.Assert(convertKind != ConvKind.Identity);
// identity conversion should have been handled at first.
}
if (convertKind != ConvKind.Implicit)
{
return(false);
}
// An implicit conversion exists. Do the conversion.
if (_exprSrc.GetConst() != null)
{
// Fold the constant cast if possible.
ConstCastResult result = _binder.bindConstantCast(_exprSrc, _exprTypeDest, _needsExprDest, out _exprDest, false);
if (result == ConstCastResult.Success)
{
return(true); // else, don't fold and use a regular cast, below.
}
}
if (isUserDefinedConversion(ptSrc, ptDest))
{
if (!_needsExprDest)
{
return(true);
}
// According the language, this is a standard conversion, but it is implemented
// through a user-defined conversion. Because it's a standard conversion, we don't
// test the NOUDC flag here.
return(_binder.bindUserDefinedConversion(_exprSrc, aggTypeSrc, _typeDest, _needsExprDest, out _exprDest, true));
}
if (_needsExprDest)
{
_binder.bindSimpleCast(_exprSrc, _exprTypeDest, out _exprDest);
}
return(true);
}
public static string GetNiceName(AggregateSymbol type) => type.IsPredefined() ? GetNiceName(type.GetPredefType()) : null;
private AggregateSymbol FindPredefinedType(ErrorHandling errorContext, string pszType, KAID aid, AggKindEnum aggKind, int arity, bool isRequired)
{
Debug.Assert(!string.IsNullOrEmpty(pszType)); // Shouldn't be the empty string!
NamespaceOrAggregateSymbol bagCur = _pBSymmgr.GetRootNS();
Name name = null;
string[] nameParts = pszType.Split(s_nameSeparators);
for (int i = 0, n = nameParts.Length; i < n; i++)
{
name = _pBSymmgr.GetNameManager().Add(nameParts[i]);
if (i == n - 1)
{
// This is the last component. Handle it special below.
break;
}
// first search for an outer type which is also predefined
// this must be first because we always create a namespace for
// outer names, even for nested types
AggregateSymbol aggNext = _pBSymmgr.LookupGlobalSymCore(name, bagCur, symbmask_t.MASK_AggregateSymbol).AsAggregateSymbol();
if (aggNext != null && aggNext.InAlias(aid) && aggNext.IsPredefined())
{
bagCur = aggNext;
}
else
{
// ... if no outer type, then search for namespaces
NamespaceSymbol nsNext = _pBSymmgr.LookupGlobalSymCore(name, bagCur, symbmask_t.MASK_NamespaceSymbol).AsNamespaceSymbol();
bool bIsInAlias = true;
if (nsNext == null)
{
bIsInAlias = false;
}
else
{
bIsInAlias = nsNext.InAlias(aid);
}
if (!bIsInAlias)
{
// Didn't find the namespace in this aid.
if (isRequired)
{
errorContext.Error(ErrorCode.ERR_PredefinedTypeNotFound, pszType);
}
return(null);
}
bagCur = nsNext;
}
}
AggregateSymbol aggAmbig;
AggregateSymbol aggBad;
AggregateSymbol aggFound = FindPredefinedTypeCore(name, bagCur, aid, aggKind, arity, out aggAmbig, out aggBad);
if (aggFound == null)
{
// Didn't find the AggregateSymbol.
if (aggBad != null && (isRequired || aid == KAID.kaidGlobal && aggBad.IsSource()))
{
errorContext.ErrorRef(ErrorCode.ERR_PredefinedTypeBadType, aggBad);
}
else if (isRequired)
{
errorContext.Error(ErrorCode.ERR_PredefinedTypeNotFound, pszType);
}
return(null);
}
if (aggAmbig == null && aid != KAID.kaidGlobal)
{
// Look in kaidGlobal to make sure there isn't a conflicting one.
AggregateSymbol tmp;
AggregateSymbol agg2 = FindPredefinedTypeCore(name, bagCur, KAID.kaidGlobal, aggKind, arity, out aggAmbig, out tmp);
Debug.Assert(agg2 != null);
if (agg2 != aggFound)
{
aggAmbig = agg2;
}
}
return(aggFound);
}
