public GenericParameterReference(Module moduleBeingBuilt, TypeParameterSymbol underlyingTypeParameter)
: base(moduleBeingBuilt)
{
Contract.ThrowIfNull(underlyingTypeParameter);
this.UnderlyingTypeParameter = underlyingTypeParameter;
}
protected internal override object VisitTypeParameter(TypeParameterSymbol symbol, ArrayBuilder<SymbolDescriptionPart> builder)
{
//variance and constraints are handled by methods and named types
builder.Add(new SymbolDescriptionPart
{
Kind = SymbolDescriptionPartKind.TypeParameterName,
Text = symbol.Name,
});
return null;
}
private void AddTypeParameterVarianceIfRequired(TypeParameterSymbol symbol, ArrayBuilder<SymbolDescriptionPart> builder)
{
if (format.GenericsFlags.HasFlag(GenericsFlags.IncludeVariance))
{
switch (symbol.Variance)
{
case VarianceKind.VarianceIn:
AddKeyword(SyntaxKind.InKeyword, builder);
AddSpace(builder);
break;
case VarianceKind.VarianceOut:
AddKeyword(SyntaxKind.OutKeyword, builder);
AddSpace(builder);
break;
}
}
}
public SynthesizedSubstitutedTypeParameterSymbol(Symbol owner, TypeMap map, TypeParameterSymbol substitutedFrom)
: base(owner, map, substitutedFrom)
{
}
internal Microsoft.Cci.IGenericParameterReference Translate(TypeParameterSymbol param)
{
Contract.ThrowIfFalse(ReferenceEquals(param, param.OriginalDefinition));
return param;
}
private static void GetGenericTypeParameterSymbol(int position, NamedTypeSymbol namedType, out int cumulativeArity, out TypeParameterSymbol typeArgument)
{
cumulativeArity = namedType.Arity;
typeArgument = null;
int arityOffset = 0;
var containingType = namedType.ContainingType;
if ((object)containingType != null)
{
int containingTypeCumulativeArity;
GetGenericTypeParameterSymbol(position, containingType, out containingTypeCumulativeArity, out typeArgument);
cumulativeArity += containingTypeCumulativeArity;
arityOffset = containingTypeCumulativeArity;
}
if (arityOffset <= position && position < cumulativeArity)
{
Debug.Assert((object)typeArgument == null);
typeArgument = namedType.TypeParameters[position - arityOffset];
}
}
private void AddUserDefinedConversionsToExplicitCandidateSet(
BoundExpression sourceExpression,
TypeSymbol source,
TypeSymbol target,
ArrayBuilder <UserDefinedConversionAnalysis> u,
TypeParameterSymbol constrainedToTypeOpt,
NamedTypeSymbol declaringType,
string operatorName,
ref CompoundUseSiteInfo <AssemblySymbol> useSiteInfo)
{
Debug.Assert(sourceExpression != null || (object)source != null);
Debug.Assert((object)target != null);
Debug.Assert(u != null);
Debug.Assert((object)declaringType != null);
Debug.Assert(operatorName != null);
// SPEC: Find the set of applicable user-defined and lifted conversion operators, U.
// SPEC: The set consists of the user-defined and lifted implicit or explicit
// SPEC: conversion operators declared by the classes and structs in D that convert
// SPEC: from a type encompassing E or encompassed by S (if it exists) to a type
// SPEC: encompassing or encompassed by T.
// DELIBERATE SPEC VIOLATION:
//
// The spec here essentially says that we add an applicable "regular" conversion and
// an applicable lifted conversion, if there is one, to the candidate set, and then
// let them duke it out to determine which one is "best".
//
// This is not at all what the native compiler does, and attempting to implement
// the specification, or slight variations on it, produces too many backwards-compatibility
// breaking changes.
//
// The native compiler deviates from the specification in two major ways here.
// First, it does not add *both* the regular and lifted forms to the candidate set.
// Second, the way it characterizes a "lifted" form is very, very different from
// how the specification characterizes a lifted form.
//
// An operation, in this case, X-->Y, is properly said to be "lifted" to X?-->Y? via
// the rule that X?-->Y? matches the behavior of X-->Y for non-null X, and converts
// null X to null Y otherwise.
//
// The native compiler, by contrast, takes the existing operator and "lifts" either
// the operator's parameter type or the operator's return type to nullable. For
// example, a conversion from X?-->Y would be "lifted" to X?-->Y? by making the
// conversion from X? to Y, and then from Y to Y?. No "lifting" semantics
// are imposed; we do not check to see if the X? is null. This operator is not
// actually "lifted" at all; rather, an implicit conversion is applied to the
// output. **The native compiler considers the result type Y? of that standard implicit
// conversion to be the result type of the "lifted" conversion**, rather than
// properly considering Y to be the result type of the conversion for the purposes
// of computing the best output type.
//
// Moreover: the native compiler actually *does* implement nullable lifting semantics
// in the case where the input type of the user-defined conversion is a non-nullable
// value type and the output type is a nullable value type **or pointer type, or
// reference type**. This is an enormous departure from the specification; the
// native compiler will take a user-defined conversion from X-->Y? or X-->C and "lift"
// it to a conversion from X?-->Y? or X?-->C that has nullable semantics.
//
// This is quite confusing. In this code we will classify the conversion as either
// "normal" or "lifted" on the basis of *whether or not special lifting semantics
// are to be applied*. That is, whether or not a later rewriting pass is going to
// need to insert a check to see if the source expression is null, and decide
// whether or not to call the underlying unlifted conversion or produce a null
// value without calling the unlifted conversion.
// DELIBERATE SPEC VIOLATION: See the comment regarding bug 17021 in
// UserDefinedImplicitConversions.cs.
if ((object)source != null && source.IsInterfaceType() || target.IsInterfaceType())
{
return;
}
foreach (MethodSymbol op in declaringType.GetOperators(operatorName))
{
// We might have a bad operator and be in an error recovery situation. Ignore it.
if (op.ReturnsVoid || op.ParameterCount != 1 || op.ReturnType.TypeKind == TypeKind.Error)
{
continue;
}
TypeSymbol convertsFrom = op.GetParameterType(0);
TypeSymbol convertsTo = op.ReturnType;
Conversion fromConversion = EncompassingExplicitConversion(sourceExpression, source, convertsFrom, ref useSiteInfo);
Conversion toConversion = EncompassingExplicitConversion(null, convertsTo, target, ref useSiteInfo);
// We accept candidates for which the parameter type encompasses the *underlying* source type.
if (!fromConversion.Exists &&
(object)source != null &&
source.IsNullableType() &&
EncompassingExplicitConversion(null, source.GetNullableUnderlyingType(), convertsFrom, ref useSiteInfo).Exists)
{
fromConversion = ClassifyBuiltInConversion(source, convertsFrom, ref useSiteInfo);
}
// As in dev11 (and the revised spec), we also accept candidates for which the return type is encompassed by the *stripped* target type.
if (!toConversion.Exists &&
(object)target != null &&
target.IsNullableType() &&
EncompassingExplicitConversion(null, convertsTo, target.GetNullableUnderlyingType(), ref useSiteInfo).Exists)
{
toConversion = ClassifyBuiltInConversion(convertsTo, target, ref useSiteInfo);
}
// In the corresponding implicit conversion code we can get away with first
// checking to see if standard implicit conversions exist from the source type
// to the parameter type, and from the return type to the target type. If not,
// then we can check for a lifted operator.
//
// That's not going to cut it in the explicit conversion code. Suppose we have
// a conversion X-->Y and have source type X? and target type Y?. There *are*
// standard explicit conversions from X?-->X and Y?-->Y, but we do not want
// to bind this as an *unlifted* conversion from X? to Y?; we want such a thing
// to be a *lifted* conversion from X? to Y?, that checks for null on the source
// and decides to not call the underlying user-defined conversion if it is null.
//
// We therefore cannot do what we do in the implicit conversions, where we check
// to see if the unlifted conversion works, and if it does, then don't add the lifted
// conversion at all. Rather, we have to see if what we're building here is a
// lifted conversion or not.
//
// Under what circumstances is this conversion a lifted conversion? (In the
// "spec" sense of a lifted conversion; that is, that we check for null
// and skip the user-defined conversion if necessary).
//
// * The source type must be a nullable value type.
// * The parameter type must be a non-nullable value type.
// * The target type must be able to take on a null value.
if (fromConversion.Exists && toConversion.Exists)
{
if ((object)source != null && source.IsNullableType() && convertsFrom.IsNonNullableValueType() && target.CanBeAssignedNull())
{
TypeSymbol nullableFrom = MakeNullableType(convertsFrom);
TypeSymbol nullableTo = convertsTo.IsNonNullableValueType() ? MakeNullableType(convertsTo) : convertsTo;
Conversion liftedFromConversion = EncompassingExplicitConversion(sourceExpression, source, nullableFrom, ref useSiteInfo);
Conversion liftedToConversion = EncompassingExplicitConversion(null, nullableTo, target, ref useSiteInfo);
Debug.Assert(liftedFromConversion.Exists);
Debug.Assert(liftedToConversion.Exists);
u.Add(UserDefinedConversionAnalysis.Lifted(constrainedToTypeOpt, op, liftedFromConversion, liftedToConversion, nullableFrom, nullableTo));
}
else
{
// There is an additional spec violation in the native compiler. Suppose
// we have a conversion from X-->Y and are asked to do "Y? y = new X();" Clearly
// the intention is to convert from X-->Y via the implicit conversion, and then
// stick a standard implicit conversion from Y-->Y? on the back end. **In this
// situation, the native compiler treats the conversion as though it were
// actually X-->Y? in source for the purposes of determining the best target
// type of a set of operators.
//
// Similarly, if we have a conversion from X-->Y and are asked to do
// an explicit conversion from X? to Y then we treat the conversion as
// though it really were X?-->Y for the purposes of determining the best
// source type of a set of operators.
//
// We perpetuate these fictions here.
if (target.IsNullableType() && convertsTo.IsNonNullableValueType())
{
convertsTo = MakeNullableType(convertsTo);
toConversion = EncompassingExplicitConversion(null, convertsTo, target, ref useSiteInfo);
}
if ((object)source != null && source.IsNullableType() && convertsFrom.IsNonNullableValueType())
{
convertsFrom = MakeNullableType(convertsFrom);
fromConversion = EncompassingExplicitConversion(null, convertsFrom, source, ref useSiteInfo);
}
u.Add(UserDefinedConversionAnalysis.Normal(constrainedToTypeOpt, op, fromConversion, toConversion, convertsFrom, convertsTo));
}
}
}
}
public RetargetingTypeParameterSymbol(RetargetingModuleSymbol retargetingModule, TypeParameterSymbol underlyingTypeParameter)
: base(underlyingTypeParameter)
{
Debug.Assert((object)retargetingModule != null);
Debug.Assert(!(underlyingTypeParameter is RetargetingTypeParameterSymbol));
_retargetingModule = retargetingModule;
}
internal Microsoft.Cci.IGenericParameterReference Translate(TypeParameterSymbol param)
{
Contract.ThrowIfFalse(ReferenceEquals(param, param.OriginalDefinition));
return(param);
}
public GenericParameterDefinition(Module moduleBeingBuilt, TypeParameterSymbol underlyingTypeParameter)
: base(moduleBeingBuilt, underlyingTypeParameter)
{
}
internal static void AssertReferencedIsUnmanagedAttribute(Accessibility accessibility, TypeParameterSymbol typeParameter, string assemblyName)
{
var attributes = ((PEModuleSymbol)typeParameter.ContainingModule).GetCustomAttributesForToken(((PETypeParameterSymbol)typeParameter).Handle);
NamedTypeSymbol attributeType = attributes.Single().AttributeClass;
Assert.Equal("IsUnmanagedAttribute", attributeType.Name);
Assert.Equal(assemblyName, attributeType.ContainingAssembly.Name);
Assert.Equal(accessibility, attributeType.DeclaredAccessibility);
switch (accessibility)
{
case Accessibility.Internal:
{
var isUnmanagedTypeAttributes = attributeType.GetAttributes().OrderBy(attribute => attribute.AttributeClass.Name).ToArray();
Assert.Equal(2, isUnmanagedTypeAttributes.Length);
Assert.Equal(WellKnownTypes.GetMetadataName(WellKnownType.System_Runtime_CompilerServices_CompilerGeneratedAttribute), isUnmanagedTypeAttributes[0].AttributeClass.ToDisplayString());
Assert.Equal(AttributeDescription.CodeAnalysisEmbeddedAttribute.FullName, isUnmanagedTypeAttributes[1].AttributeClass.ToDisplayString());
break;
}
case Accessibility.Public:
{
Assert.Null(attributeType.ContainingAssembly.GetTypeByMetadataName(AttributeDescription.CodeAnalysisEmbeddedAttribute.FullName));
break;
}
default:
throw ExceptionUtilities.UnexpectedValue(accessibility);
}
}
public GenericMethodParameterReference(Module moduleBeingBuilt, TypeParameterSymbol underlyingTypeParameter)
: base(moduleBeingBuilt, underlyingTypeParameter)
{
}
public SynthesizedSubstitutedTypeParameterSymbol(Symbol owner, TypeMap map, TypeParameterSymbol substitutedFrom, int ordinal)
: base(owner, map, substitutedFrom, ordinal)
{
}
private BoundExpression MakeNewT(CSharpSyntaxNode syntax, TypeParameterSymbol typeParameter)
{
// How "new T()" is rewritten depends on whether T is known to be a value
// type, a reference type, or neither (see OperatorRewriter::VisitNEWTYVAR).
if (typeParameter.IsValueType)
{
// "new T()" rewritten as: "default(T)".
return(new BoundDefaultOperator(syntax, type: typeParameter));
}
// For types not known to be value types, "new T()" requires
// Activator.CreateInstance<T>().
MethodSymbol method;
if (!this.TryGetWellKnownTypeMember(syntax, WellKnownMember.System_Activator__CreateInstance_T, out method))
{
return(new BoundDefaultOperator(syntax, null, type: typeParameter, hasErrors: true));
}
Debug.Assert((object)method != null);
method = method.Construct(ImmutableArray.Create <TypeSymbol>(typeParameter));
var createInstanceCall = new BoundCall(
syntax,
null,
method,
ImmutableArray <BoundExpression> .Empty,
default(ImmutableArray <string>),
default(ImmutableArray <RefKind>),
isDelegateCall: false,
expanded: false,
invokedAsExtensionMethod: false,
argsToParamsOpt: default(ImmutableArray <int>),
resultKind: LookupResultKind.Viable,
type: typeParameter);
if (typeParameter.IsReferenceType)
{
// "new T()" is rewritten as: "Activator.CreateInstance<T>()".
return(createInstanceCall);
}
else
{
// "new T()" is rewritten as: "(null == (object)default(T)) ? Activator.CreateInstance<T>() : default(T)".
var defaultT = new BoundDefaultOperator(syntax, type: typeParameter);
return(new BoundConditionalOperator(
syntax,
MakeNullCheck(
syntax: syntax,
rewrittenExpr: MakeConversion(
syntax: syntax,
rewrittenOperand: defaultT,
conversionKind: ConversionKind.Boxing,
rewrittenType: this.compilation.GetSpecialType(SpecialType.System_Object),
@checked: false),
operatorKind: BinaryOperatorKind.Equal),
createInstanceCall,
defaultT,
constantValueOpt: null,
type: typeParameter));
}
}
private static bool TypeParameterHasContraints(TypeParameterSymbol typeParam)
{
return !typeParam.ConstraintTypes.IsEmpty() || typeParam.HasConstructorConstraint ||
typeParam.HasReferenceTypeConstraint || typeParam.HasValueTypeConstraint;
}
public virtual void VisitTypeParameter(TypeParameterSymbol symbol)
{
DefaultVisit(symbol);
}
public override Symbol VisitTypeParameter(TypeParameterSymbol symbol)
{
return(symbol);
}
public static NamedTypeSymbol GetEffectiveBaseClass(this TypeParameterSymbol type)
{
return(type.BaseType);
}
public override Microsoft.Cci.IReference VisitTypeParameter(TypeParameterSymbol symbol, bool a)
{
return(Translate(symbol));
}
/// <summary>
/// Determine whether there is any substitution of type parameters that will
/// make two types identical.
/// </summary>
/// <param name="t1">LHS</param>
/// <param name="t2">RHS</param>
/// <param name="substitution">
/// Substitutions performed so far (or null for none).
/// Keys are type parameters, values are types (possibly type parameters).
/// Will be updated with new substitutions by the callee.
/// Should be ignored when false is returned.
/// </param>
/// <returns>True if there exists a type map such that Map(LHS) == Map(RHS).</returns>
/// <remarks>
/// Derived from Dev10's BSYMMGR::UnifyTypes.
/// Two types will not unify if they have different custom modifiers.
/// </remarks>
private static bool CanUnifyHelper(TypeSymbol t1, TypeSymbol t2, ref MutableTypeMap substitution)
{
if (ReferenceEquals(t1, t2))
{
return(true);
}
else if ((object)t1 == null || (object)t2 == null)
{
// Can't both be null or they would have been ReferenceEquals
return(false);
}
if (substitution != null)
{
t1 = substitution.SubstituteType(t1);
t2 = substitution.SubstituteType(t2);
}
// If one of the types is a type parameter, then the substitution could make them ReferenceEquals.
if (ReferenceEquals(t1, t2))
{
return(true);
}
// We can avoid a lot of redundant checks if we ensure that we only have to check
// for type parameters on the LHS
if (!t1.IsTypeParameter() && t2.IsTypeParameter())
{
TypeSymbol tmp = t1;
t1 = t2;
t2 = tmp;
}
// If t1 is not a type parameter, then neither is t2
Debug.Assert(t1.IsTypeParameter() || !t2.IsTypeParameter());
switch (t1.Kind)
{
case SymbolKind.ArrayType:
{
if (t2.TypeKind != t1.TypeKind)
{
return(false);
}
ArrayTypeSymbol at1 = (ArrayTypeSymbol)t1;
ArrayTypeSymbol at2 = (ArrayTypeSymbol)t2;
if (at1.Rank != at2.Rank || !at1.CustomModifiers.SequenceEqual(at2.CustomModifiers))
{
return(false);
}
return(CanUnifyHelper(at1.ElementType, at2.ElementType, ref substitution));
}
case SymbolKind.PointerType:
{
if (t2.TypeKind != t1.TypeKind)
{
return(false);
}
PointerTypeSymbol pt1 = (PointerTypeSymbol)t1;
PointerTypeSymbol pt2 = (PointerTypeSymbol)t2;
if (!pt1.CustomModifiers.SequenceEqual(pt2.CustomModifiers))
{
return(false);
}
return(CanUnifyHelper(pt1.PointedAtType, pt2.PointedAtType, ref substitution));
}
case SymbolKind.NamedType:
case SymbolKind.ErrorType:
{
if (t2.TypeKind != t1.TypeKind)
{
return(false);
}
NamedTypeSymbol nt1 = (NamedTypeSymbol)t1;
NamedTypeSymbol nt2 = (NamedTypeSymbol)t2;
if (!nt1.IsGenericType)
{
return(!nt2.IsGenericType && nt1 == nt2);
}
else if (!nt2.IsGenericType)
{
return(false);
}
int arity = nt1.Arity;
if (nt2.Arity != arity || nt2.OriginalDefinition != nt1.OriginalDefinition)
{
return(false);
}
for (int i = 0; i < arity; i++)
{
if (!CanUnifyHelper(nt1.TypeArgumentsNoUseSiteDiagnostics[i], nt2.TypeArgumentsNoUseSiteDiagnostics[i], ref substitution))
{
return(false);
}
}
// Note: Dev10 folds this into the loop since GetTypeArgsAll includes type args for containing types
return((object)nt1.ContainingType == null || CanUnifyHelper(nt1.ContainingType, nt2.ContainingType, ref substitution));
}
case SymbolKind.TypeParameter:
{
// These substitutions are not allowed in C#
if (t2.TypeKind == TypeKind.Pointer || t2.SpecialType == SpecialType.System_Void)
{
return(false);
}
TypeParameterSymbol tp1 = (TypeParameterSymbol)t1;
// Perform the "occurs check" - i.e. ensure that t2 doesn't contain t1 to avoid recursive types
// Note: t2 can't be the same type param - we would have caught that with ReferenceEquals above
if (Contains(t2, tp1))
{
return(false);
}
if (substitution == null)
{
substitution = new MutableTypeMap();
}
// MutableTypeMap.Add will throw if the key has already been added. However,
// if t1 was already in the substitution, it would have been substituted at the
// start of this method and we wouldn't be here.
substitution.Add(tp1, t2);
return(true);
}
default:
{
return(t1 == t2);
}
}
}
public static ImmutableArray <TypeSymbol> ConstraintTypes(this TypeParameterSymbol symbol)
{
return(TypeMap.AsTypeSymbols(symbol.ConstraintTypesNoUseSiteDiagnostics));
}
/// <summary>
/// Called when visiting a <see cref="TypeParameterSymbol" />; Override this with specific
/// implementation; Calling <see cref="DefaultVisit" /> if it's not overridden
/// </summary>
/// <param name="symbol">The visited symbol</param>
/// <param name="argument">Additional argument</param>
/// <returns></returns>
public virtual TResult VisitTypeParameter(TypeParameterSymbol symbol, TArgument argument)
{
return(DefaultVisit(symbol, argument));
}
public virtual TResult VisitTypeParameter(TypeParameterSymbol symbol)
{
return(DefaultVisit(symbol));
}
/// <summary>
/// Determine whether there is any substitution of type parameters that will
/// make two types identical.
/// </summary>
/// <param name="t1">LHS</param>
/// <param name="t2">RHS</param>
/// <param name="substitution">
/// Substitutions performed so far (or null for none).
/// Keys are type parameters, values are types (possibly type parameters).
/// Will be updated with new substitutions by the callee.
/// Should be ignored when false is returned.
/// </param>
/// <returns>True if there exists a type map such that Map(LHS) == Map(RHS).</returns>
/// <remarks>
/// Derived from Dev10's BSYMMGR::UnifyTypes.
/// Two types will not unify if they have different custom modifiers.
/// </remarks>
private static bool CanUnifyHelper(TypeWithAnnotations t1, TypeWithAnnotations t2, ref MutableTypeMap substitution)
{
if (!t1.HasType || !t2.HasType)
{
return(t1.IsSameAs(t2));
}
if (TypeSymbol.Equals(t1.Type, t2.Type, TypeCompareKind.ConsiderEverything2) && t1.CustomModifiers.SequenceEqual(t2.CustomModifiers))
{
return(true);
}
if (substitution != null)
{
t1 = t1.SubstituteType(substitution);
t2 = t2.SubstituteType(substitution);
}
// If one of the types is a type parameter, then the substitution could make them equal.
if (TypeSymbol.Equals(t1.Type, t2.Type, TypeCompareKind.ConsiderEverything2) && t1.CustomModifiers.SequenceEqual(t2.CustomModifiers))
{
return(true);
}
// We can avoid a lot of redundant checks if we ensure that we only have to check
// for type parameters on the LHS
if (!t1.Type.IsTypeParameter() && t2.Type.IsTypeParameter())
{
TypeWithAnnotations tmp = t1;
t1 = t2;
t2 = tmp;
}
// If t1 is not a type parameter, then neither is t2
Debug.Assert(t1.Type.IsTypeParameter() || !t2.Type.IsTypeParameter());
switch (t1.Type.Kind)
{
case SymbolKind.ArrayType:
{
if (t2.TypeKind != t1.TypeKind || !t2.CustomModifiers.SequenceEqual(t1.CustomModifiers))
{
return(false);
}
ArrayTypeSymbol at1 = (ArrayTypeSymbol)t1.Type;
ArrayTypeSymbol at2 = (ArrayTypeSymbol)t2.Type;
if (!at1.HasSameShapeAs(at2))
{
return(false);
}
return(CanUnifyHelper(at1.ElementTypeWithAnnotations, at2.ElementTypeWithAnnotations, ref substitution));
}
case SymbolKind.PointerType:
{
if (t2.TypeKind != t1.TypeKind || !t2.CustomModifiers.SequenceEqual(t1.CustomModifiers))
{
return(false);
}
PointerTypeSymbol pt1 = (PointerTypeSymbol)t1.Type;
PointerTypeSymbol pt2 = (PointerTypeSymbol)t2.Type;
return(CanUnifyHelper(pt1.PointedAtTypeWithAnnotations, pt2.PointedAtTypeWithAnnotations, ref substitution));
}
case SymbolKind.NamedType:
case SymbolKind.ErrorType:
{
if (t2.TypeKind != t1.TypeKind || !t2.CustomModifiers.SequenceEqual(t1.CustomModifiers))
{
return(false);
}
NamedTypeSymbol nt1 = (NamedTypeSymbol)t1.Type;
NamedTypeSymbol nt2 = (NamedTypeSymbol)t2.Type;
if (nt1.IsTupleType)
{
if (!nt2.IsTupleType)
{
return(false);
}
return(CanUnifyHelper(nt1.TupleUnderlyingType, nt2.TupleUnderlyingType, ref substitution));
}
if (!nt1.IsGenericType)
{
return(!nt2.IsGenericType && TypeSymbol.Equals(nt1, nt2, TypeCompareKind.ConsiderEverything2));
}
else if (!nt2.IsGenericType)
{
return(false);
}
int arity = nt1.Arity;
if (nt2.Arity != arity || !TypeSymbol.Equals(nt2.OriginalDefinition, nt1.OriginalDefinition, TypeCompareKind.ConsiderEverything2))
{
return(false);
}
var nt1Arguments = nt1.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics;
var nt2Arguments = nt2.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics;
for (int i = 0; i < arity; i++)
{
if (!CanUnifyHelper(nt1Arguments[i],
nt2Arguments[i],
ref substitution))
{
return(false);
}
}
// Note: Dev10 folds this into the loop since GetTypeArgsAll includes type args for containing types
// TODO: Calling CanUnifyHelper for the containing type is an overkill, we simply need to go through type arguments for all containers.
return((object)nt1.ContainingType == null || CanUnifyHelper(nt1.ContainingType, nt2.ContainingType, ref substitution));
}
case SymbolKind.TypeParameter:
{
// These substitutions are not allowed in C#
if (t2.TypeKind == TypeKind.Pointer || t2.IsVoidType())
{
return(false);
}
TypeParameterSymbol tp1 = (TypeParameterSymbol)t1.Type;
// Perform the "occurs check" - i.e. ensure that t2 doesn't contain t1 to avoid recursive types
// Note: t2 can't be the same type param - we would have caught that with ReferenceEquals above
if (Contains(t2.Type, tp1))
{
return(false);
}
if (t1.CustomModifiers.IsDefaultOrEmpty)
{
AddSubstitution(ref substitution, tp1, t2);
return(true);
}
if (t1.CustomModifiers.SequenceEqual(t2.CustomModifiers))
{
AddSubstitution(ref substitution, tp1, TypeWithAnnotations.Create(t2.Type));
return(true);
}
if (t1.CustomModifiers.Length < t2.CustomModifiers.Length &&
t1.CustomModifiers.SequenceEqual(t2.CustomModifiers.Take(t1.CustomModifiers.Length)))
{
AddSubstitution(ref substitution, tp1,
TypeWithAnnotations.Create(t2.Type,
customModifiers: ImmutableArray.Create(t2.CustomModifiers, t1.CustomModifiers.Length, t2.CustomModifiers.Length - t1.CustomModifiers.Length)));
return(true);
}
if (t2.Type.IsTypeParameter())
{
var tp2 = (TypeParameterSymbol)t2.Type;
if (t2.CustomModifiers.IsDefaultOrEmpty)
{
AddSubstitution(ref substitution, tp2, t1);
return(true);
}
if (t2.CustomModifiers.Length < t1.CustomModifiers.Length &&
t2.CustomModifiers.SequenceEqual(t1.CustomModifiers.Take(t2.CustomModifiers.Length)))
{
AddSubstitution(ref substitution, tp2,
TypeWithAnnotations.Create(t1.Type,
customModifiers: ImmutableArray.Create(t1.CustomModifiers, t2.CustomModifiers.Length, t1.CustomModifiers.Length - t2.CustomModifiers.Length)));
return(true);
}
}
return(false);
}
default:
{
return(false);
}
}
}
public GenericTypeParameterReference(Module moduleBeingBuilt, TypeParameterSymbol underlyingTypeParameter)
: base(moduleBeingBuilt, underlyingTypeParameter)
{ }
public override void VisitTypeParameter(TypeParameterSymbol typeParameter)
{
ReportSymbol(typeParameter);
}
public override Microsoft.Cci.IReference VisitTypeParameter(TypeParameterSymbol symbol, bool a)
{
return Translate(symbol);
}
public EmbeddedTypeParameter(EmbeddedMethod containingMethod, TypeParameterSymbol underlyingTypeParameter) :
base(containingMethod, underlyingTypeParameter)
{
Debug.Assert(underlyingTypeParameter.IsDefinition);
}
public GenericTypeParameterDefinition(Module moduleBeingBuilt, TypeParameterSymbol underlyingTypeParameter)
: base(moduleBeingBuilt, underlyingTypeParameter)
{ }
public RetargetingTypeParameterSymbol(RetargetingModuleSymbol retargetingModule, TypeParameterSymbol underlyingTypeParameter)
{
Debug.Assert((object)retargetingModule != null);
Debug.Assert((object)underlyingTypeParameter != null);
Debug.Assert(!(underlyingTypeParameter is RetargetingTypeParameterSymbol));
this.retargetingModule = retargetingModule;
this.underlyingTypeParameter = underlyingTypeParameter;
}
