/// <summary>
/// Does an expression of type <paramref name="expressionType"/> "match" a pattern that looks for
/// type <paramref name="patternType"/>?
/// 'true' if the matched type catches all of them, 'false' if it catches none of them, and
/// 'null' if it might catch some of them.
/// </summary>
internal static bool?ExpressionOfTypeMatchesPatternType(
Conversions conversions,
TypeSymbol expressionType,
TypeSymbol patternType,
ref HashSet <DiagnosticInfo> useSiteDiagnostics,
out Conversion conversion,
ConstantValue operandConstantValue = null,
bool operandCouldBeNull = false)
{
Debug.Assert((object)expressionType != null);
if (expressionType.IsDynamic())
{
// if operand is the dynamic type, we do the same thing as though it were object
expressionType = conversions.CorLibrary.GetSpecialType(SpecialType.System_Object);
}
conversion = conversions.ClassifyConversionFromType(expressionType, patternType, ref useSiteDiagnostics);
var result = Binder.GetIsOperatorConstantResult(expressionType, patternType, conversion.Kind, operandConstantValue, operandCouldBeNull);
return
((result == null) ? (bool?)null :
(result == ConstantValue.True) ? true :
(result == ConstantValue.False) ? false :
throw ExceptionUtilities.UnexpectedValue(result));
}
internal static bool IsValidObjectEquality(Conversions Conversions, TypeSymbol leftType, bool leftIsNull, TypeSymbol rightType, bool rightIsNull, ref HashSet <DiagnosticInfo> useSiteDiagnostics)
{
// SPEC: The predefined reference type equality operators require one of the following:
// SPEC: (1) Both operands are a value of a type known to be a reference-type or the literal null.
// SPEC: Furthermore, an explicit reference conversion exists from the type of either
// SPEC: operand to the type of the other operand. Or:
// SPEC: (2) One operand is a value of type T where T is a type-parameter and the other operand is
// SPEC: the literal null. Furthermore T does not have the value type constraint.
// SPEC ERROR: Notice that the spec calls out that an explicit reference conversion must exist;
// SPEC ERROR: in fact it should say that an explicit reference conversion, implicit reference
// SPEC ERROR: conversion or identity conversion must exist. The conversion from object to object
// SPEC ERROR: is not classified as a reference conversion at all; it is an identity conversion.
// Dev10 does not follow the spec exactly for type parameters. Specifically, in Dev10,
// if a type parameter argument is known to be a value type, or if a type parameter
// argument is not known to be either a value type or reference type and the other
// argument is not null, reference type equality cannot be applied. Otherwise, the
// effective base class of the type parameter is used to determine the conversion
// to the other argument type. (See ExpressionBinder::GetRefEqualSigs.)
if (((object)leftType != null) && leftType.IsTypeParameter())
{
if (leftType.IsValueType || (!leftType.IsReferenceType && !rightIsNull))
{
return(false);
}
leftType = ((TypeParameterSymbol)leftType).EffectiveBaseClass(ref useSiteDiagnostics);
Debug.Assert((object)leftType != null);
}
if (((object)rightType != null) && rightType.IsTypeParameter())
{
if (rightType.IsValueType || (!rightType.IsReferenceType && !leftIsNull))
{
return(false);
}
rightType = ((TypeParameterSymbol)rightType).EffectiveBaseClass(ref useSiteDiagnostics);
Debug.Assert((object)rightType != null);
}
var leftIsReferenceType = ((object)leftType != null) && leftType.IsReferenceType;
if (!leftIsReferenceType && !leftIsNull)
{
return(false);
}
var rightIsReferenceType = ((object)rightType != null) && rightType.IsReferenceType;
if (!rightIsReferenceType && !rightIsNull)
{
return(false);
}
// If at least one side is null then clearly a conversion exists.
if (leftIsNull || rightIsNull)
{
return(true);
}
var leftConversion = Conversions.ClassifyConversionFromType(leftType, rightType, ref useSiteDiagnostics);
if (leftConversion.IsIdentity || leftConversion.IsReference)
{
return(true);
}
var rightConversion = Conversions.ClassifyConversionFromType(rightType, leftType, ref useSiteDiagnostics);
if (rightConversion.IsIdentity || rightConversion.IsReference)
{
return(true);
}
return(false);
}
internal static bool IsValidObjectEquality(Conversions Conversions, TypeSymbol leftType, bool leftIsNull, TypeSymbol rightType, bool rightIsNull, ref HashSet<DiagnosticInfo> useSiteDiagnostics)
{
// SPEC: The predefined reference type equality operators require one of the following:
// SPEC: (1) Both operands are a value of a type known to be a reference-type or the literal null.
// SPEC: Furthermore, an explicit reference conversion exists from the type of either
// SPEC: operand to the type of the other operand. Or:
// SPEC: (2) One operand is a value of type T where T is a type-parameter and the other operand is
// SPEC: the literal null. Furthermore T does not have the value type constraint.
// SPEC ERROR: Notice that the spec calls out that an explicit reference conversion must exist;
// SPEC ERROR: in fact it should say that an explicit reference conversion, implicit reference
// SPEC ERROR: conversion or identity conversion must exist. The conversion from object to object
// SPEC ERROR: is not classified as a reference conversion at all; it is an identity conversion.
// Dev10 does not follow the spec exactly for type parameters. Specifically, in Dev10,
// if a type parameter argument is known to be a value type, or if a type parameter
// argument is not known to be either a value type or reference type and the other
// argument is not null, reference type equality cannot be applied. Otherwise, the
// effective base class of the type parameter is used to determine the conversion
// to the other argument type. (See ExpressionBinder::GetRefEqualSigs.)
if (((object)leftType != null) && leftType.IsTypeParameter())
{
if (leftType.IsValueType || (!leftType.IsReferenceType && !rightIsNull))
{
return false;
}
leftType = ((TypeParameterSymbol)leftType).EffectiveBaseClass(ref useSiteDiagnostics);
Debug.Assert((object)leftType != null);
}
if (((object)rightType != null) && rightType.IsTypeParameter())
{
if (rightType.IsValueType || (!rightType.IsReferenceType && !leftIsNull))
{
return false;
}
rightType = ((TypeParameterSymbol)rightType).EffectiveBaseClass(ref useSiteDiagnostics);
Debug.Assert((object)rightType != null);
}
var leftIsReferenceType = ((object)leftType != null) && leftType.IsReferenceType;
if (!leftIsReferenceType && !leftIsNull)
{
return false;
}
var rightIsReferenceType = ((object)rightType != null) && rightType.IsReferenceType;
if (!rightIsReferenceType && !rightIsNull)
{
return false;
}
// If at least one side is null then clearly a conversion exists.
if (leftIsNull || rightIsNull)
{
return true;
}
var leftConversion = Conversions.ClassifyConversionFromType(leftType, rightType, ref useSiteDiagnostics);
if (leftConversion.IsIdentity || leftConversion.IsReference)
{
return true;
}
var rightConversion = Conversions.ClassifyConversionFromType(rightType, leftType, ref useSiteDiagnostics);
if (rightConversion.IsIdentity || rightConversion.IsReference)
{
return true;
}
return false;
}
private BoundExpression BindCodeblock(SyntaxNode syntax, UnboundLambda unboundLambda, Conversion conversion, bool isCast, TypeSymbol destination, DiagnosticBag diagnostics)
{
if (!Compilation.Options.HasRuntime)
{
return(null);
}
var isCodeblock = syntax.XIsCodeBlock;
if (!isCodeblock)
{
isCodeblock = !destination.IsDelegateType() && !destination.IsExpressionTree();
}
if (!isCodeblock)
{
return(null);
}
Conversion conv = Conversion.ImplicitReference;
if (destination != Compilation.CodeBlockType() && !destination.IsObjectType())
{
HashSet <DiagnosticInfo> useSiteDiagnostics = null;
conv = Conversions.ClassifyConversionFromType(Compilation.CodeBlockType(), destination, ref useSiteDiagnostics);
diagnostics.Add(syntax, useSiteDiagnostics);
}
if (Compilation.Options.HasRuntime)
{
Debug.Assert(destination == Compilation.CodeBlockType() || conv.Exists);
}
if (!syntax.XIsCodeBlock && !Compilation.Options.MacroScript && !syntax.XNode.IsAliasExpression())
{
Error(diagnostics, ErrorCode.ERR_CodeblockWithLambdaSyntax, syntax);
}
AnonymousTypeManager manager = this.Compilation.AnonymousTypeManager;
var delegateSignature = new TypeSymbol[unboundLambda.ParameterCount + 1];
var usualType = this.Compilation.UsualType();
for (int i = 0; i < delegateSignature.Length; i++)
{
delegateSignature[i] = usualType;
}
NamedTypeSymbol cbType = manager.ConstructCodeblockTypeSymbol(delegateSignature, syntax.Location);
var delType = manager.GetCodeblockDelegateType(cbType);
var _boundLambda = unboundLambda.Bind(delType);
diagnostics.AddRange(_boundLambda.Diagnostics);
var cbDel = new BoundConversion(
syntax,
_boundLambda,
conversion,
@checked: false,
explicitCastInCode: false,
constantValueOpt: ConstantValue.NotAvailable,
type: delType)
{
WasCompilerGenerated = unboundLambda.WasCompilerGenerated
};
var cbSrc = new BoundLiteral(syntax, ConstantValue.Create(syntax.XCodeBlockSource), Compilation.GetSpecialType(SpecialType.System_String));
BoundExpression cbInst = new BoundAnonymousObjectCreationExpression(syntax,
cbType.InstanceConstructors[0],
new BoundExpression[] { cbDel, cbSrc }.ToImmutableArrayOrEmpty(),
System.Collections.Immutable.ImmutableArray <BoundAnonymousPropertyDeclaration> .Empty, cbType)
{
WasCompilerGenerated = unboundLambda.WasCompilerGenerated
};;
if (conv != Conversion.ImplicitReference)
{
cbInst = new BoundConversion(syntax, cbInst, Conversion.ImplicitReference, false, false, ConstantValue.NotAvailable, Compilation.CodeBlockType())
{
WasCompilerGenerated = unboundLambda.WasCompilerGenerated
};;
}
if (!conv.IsValid || (!isCast && conv.IsExplicit))
{
GenerateImplicitConversionError(diagnostics, syntax, conv, cbInst, destination);
return(new BoundConversion(
syntax,
cbInst,
conv,
false,
explicitCastInCode: isCast,
constantValueOpt: ConstantValue.NotAvailable,
type: destination,
hasErrors: true)
{
WasCompilerGenerated = unboundLambda.WasCompilerGenerated
});
}
return(new BoundConversion(
syntax,
cbInst,
conv,
false,
explicitCastInCode: isCast,
constantValueOpt: ConstantValue.NotAvailable,
type: destination)
{
WasCompilerGenerated = unboundLambda.WasCompilerGenerated
});
}