/// <summary>
/// Returns the better type amongst the two, with some possible modifications (dynamic/object or tuple names).
/// </summary>
private static TypeSymbol Better(
TypeSymbol type1,
TypeSymbol type2,
ConversionsBase conversions,
ref HashSet <DiagnosticInfo> useSiteDiagnostics)
{
// Anything is better than an error sym.
if (type1.IsErrorType())
{
return(type2);
}
if ((object)type2 == null || type2.IsErrorType())
{
return(type1);
}
var conversionsWithoutNullability = conversions.WithNullability(false);
var t1tot2 = conversionsWithoutNullability.ClassifyImplicitConversionFromType(type1, type2, ref useSiteDiagnostics).Exists;
var t2tot1 = conversionsWithoutNullability.ClassifyImplicitConversionFromType(type2, type1, ref useSiteDiagnostics).Exists;
if (t1tot2 && t2tot1)
{
if (type1.IsDynamic())
{
return(type1);
}
if (type2.IsDynamic())
{
return(type2);
}
if (type1.Equals(type2, TypeCompareKind.IgnoreDynamicAndTupleNames | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes))
{
return(MethodTypeInferrer.Merge(
TypeWithAnnotations.Create(type1),
TypeWithAnnotations.Create(type2),
VarianceKind.Out,
conversions).Type);
}
return(null);
}
if (t1tot2)
{
return(type2);
}
if (t2tot1)
{
return(type1);
}
return(null);
}
/// <summary>
/// Returns the better type amongst the two, with some possible modifications (dynamic/object or tuple names).
/// </summary>
private TypeSymbol Better(TypeSymbol type1, TypeSymbol type2, ref HashSet <DiagnosticInfo> useSiteDiagnostics)
{
// Anything is better than an error sym.
if (type1.IsErrorType())
{
return(type2);
}
if ((object)type2 == null || type2.IsErrorType())
{
return(type1);
}
var t1tot2 = _conversions.ClassifyImplicitConversionFromType(type1, type2, ref useSiteDiagnostics).Exists;
var t2tot1 = _conversions.ClassifyImplicitConversionFromType(type2, type1, ref useSiteDiagnostics).Exists;
if (t1tot2 && t2tot1)
{
if (type1.IsDynamic())
{
return(type1);
}
if (type2.IsDynamic())
{
return(type2);
}
if (type1.Equals(type2, TypeCompareKind.IgnoreDynamicAndTupleNames))
{
return(MethodTypeInferrer.MergeTupleNames(type1, type2, MethodTypeInferrer.MergeDynamic(type1, type2, type1, _conversions.CorLibrary), _conversions.CorLibrary));
}
return(null);
}
if (t1tot2)
{
return(type2);
}
if (t2tot1)
{
return(type1);
}
return(null);
}
private static MethodSymbol InferExtensionMethodTypeArguments(MethodSymbol method, TypeSymbol thisType, CSharpCompilation compilation, ref HashSet <DiagnosticInfo> useSiteDiagnostics)
{
Debug.Assert(method.IsExtensionMethod);
Debug.Assert((object)thisType != null);
if (!method.IsGenericMethod || method != method.ConstructedFrom)
{
return(method);
}
// We never resolve extension methods on a dynamic receiver.
if (thisType.IsDynamic())
{
return(null);
}
var containingAssembly = method.ContainingAssembly;
var errorNamespace = containingAssembly.GlobalNamespace;
var conversions = new TypeConversions(containingAssembly.CorLibrary);
// There is absolutely no plausible syntax/tree that we could use for these
// synthesized literals. We could be speculatively binding a call to a PE method.
var syntaxTree = CSharpSyntaxTree.Dummy;
var syntax = (CSharpSyntaxNode)syntaxTree.GetRoot();
// Create an argument value for the "this" argument of specific type,
// and pass the same bad argument value for all other arguments.
var thisArgumentValue = new BoundLiteral(syntax, ConstantValue.Bad, thisType)
{
WasCompilerGenerated = true
};
var otherArgumentType = new ExtendedErrorTypeSymbol(errorNamespace, name: string.Empty, arity: 0, errorInfo: null, unreported: false);
var otherArgumentValue = new BoundLiteral(syntax, ConstantValue.Bad, otherArgumentType)
{
WasCompilerGenerated = true
};
var paramCount = method.ParameterCount;
var arguments = new BoundExpression[paramCount];
for (int i = 0; i < paramCount; i++)
{
var argument = (i == 0) ? thisArgumentValue : otherArgumentValue;
arguments[i] = argument;
}
var typeArgs = MethodTypeInferrer.InferTypeArgumentsFromFirstArgument(
conversions,
method,
arguments.AsImmutable(),
useSiteDiagnostics: ref useSiteDiagnostics);
if (typeArgs.IsDefault)
{
return(null);
}
// For the purpose of constraint checks we use error type symbol in place of type arguments that we couldn't infer from the first argument.
// This prevents constraint checking from failing for corresponding type parameters.
int firstNullInTypeArgs = -1;
var notInferredTypeParameters = PooledHashSet <TypeParameterSymbol> .GetInstance();
var typeParams = method.TypeParameters;
var typeArgsForConstraintsCheck = typeArgs;
for (int i = 0; i < typeArgsForConstraintsCheck.Length; i++)
{
if (!typeArgsForConstraintsCheck[i].HasType)
{
firstNullInTypeArgs = i;
var builder = ArrayBuilder <TypeWithAnnotations> .GetInstance();
builder.AddRange(typeArgsForConstraintsCheck, firstNullInTypeArgs);
for (; i < typeArgsForConstraintsCheck.Length; i++)
{
var typeArg = typeArgsForConstraintsCheck[i];
if (!typeArg.HasType)
{
notInferredTypeParameters.Add(typeParams[i]);
builder.Add(TypeWithAnnotations.Create(ErrorTypeSymbol.UnknownResultType));
}
else
{
builder.Add(typeArg);
}
}
typeArgsForConstraintsCheck = builder.ToImmutableAndFree();
break;
}
}
// Check constraints.
var diagnosticsBuilder = ArrayBuilder <TypeParameterDiagnosticInfo> .GetInstance();
var substitution = new TypeMap(typeParams, typeArgsForConstraintsCheck);
ArrayBuilder <TypeParameterDiagnosticInfo> useSiteDiagnosticsBuilder = null;
var success = method.CheckConstraints(conversions, substitution, typeParams, typeArgsForConstraintsCheck, compilation, diagnosticsBuilder, nullabilityDiagnosticsBuilderOpt: null, ref useSiteDiagnosticsBuilder,
ignoreTypeConstraintsDependentOnTypeParametersOpt: notInferredTypeParameters.Count > 0 ? notInferredTypeParameters : null);
diagnosticsBuilder.Free();
notInferredTypeParameters.Free();
if (useSiteDiagnosticsBuilder != null && useSiteDiagnosticsBuilder.Count > 0)
{
if (useSiteDiagnostics == null)
{
useSiteDiagnostics = new HashSet <DiagnosticInfo>();
}
foreach (var diag in useSiteDiagnosticsBuilder)
{
useSiteDiagnostics.Add(diag.DiagnosticInfo);
}
}
if (!success)
{
return(null);
}
// For the purpose of construction we use original type parameters in place of type arguments that we couldn't infer from the first argument.
ImmutableArray <TypeWithAnnotations> typeArgsForConstruct = typeArgs;
if (typeArgs.Any(t => !t.HasType))
{
typeArgsForConstruct = typeArgs.ZipAsArray(
method.TypeParameters,
(t, tp) => t.HasType ? t : TypeWithAnnotations.Create(tp));
}
return(method.Construct(typeArgsForConstruct));
}
/// <summary>
/// If the extension method is applicable based on the "this" argument type, return
/// the method constructed with the inferred type arguments. If the method is not an
/// unconstructed generic method, type inference is skipped. If the method is not
/// applicable, or if constraints when inferring type parameters from the "this" type
/// are not satisfied, the return value is null.
/// </summary>
public static MethodSymbol InferExtensionMethodTypeArguments(this MethodSymbol method, TypeSymbol thisType, Compilation compilation, ref HashSet <DiagnosticInfo> useSiteDiagnostics)
{
Debug.Assert(method.IsExtensionMethod);
Debug.Assert((object)thisType != null);
if (!method.IsGenericMethod || method != method.ConstructedFrom)
{
return(method);
}
// We never resolve extension methods on a dynamic receiver.
if (thisType.IsDynamic())
{
return(null);
}
var containingAssembly = method.ContainingAssembly;
var errorNamespace = containingAssembly.GlobalNamespace;
var conversions = new TypeConversions(containingAssembly.CorLibrary);
// There is absolutely no plausible syntax/tree that we could use for these
// synthesized literals. We could be speculatively binding a call to a PE method.
var syntaxTree = CSharpSyntaxTree.Dummy;
var syntax = (CSharpSyntaxNode)syntaxTree.GetRoot();
// Create an argument value for the "this" argument of specific type,
// and pass the same bad argument value for all other arguments.
var thisArgumentValue = new BoundLiteral(syntax, ConstantValue.Bad, thisType)
{
WasCompilerGenerated = true
};
var otherArgumentType = new ExtendedErrorTypeSymbol(errorNamespace, name: string.Empty, arity: 0, errorInfo: null, unreported: false);
var otherArgumentValue = new BoundLiteral(syntax, ConstantValue.Bad, otherArgumentType)
{
WasCompilerGenerated = true
};
var paramCount = method.ParameterCount;
var arguments = new BoundExpression[paramCount];
var argumentTypes = new TypeSymbol[paramCount];
for (int i = 0; i < paramCount; i++)
{
var argument = (i == 0) ? thisArgumentValue : otherArgumentValue;
arguments[i] = argument;
argumentTypes[i] = argument.Type;
}
var typeArgs = MethodTypeInferrer.InferTypeArgumentsFromFirstArgument(
conversions,
method,
argumentTypes.AsImmutableOrNull(),
arguments.AsImmutableOrNull(),
ref useSiteDiagnostics);
if (typeArgs.IsDefault)
{
return(null);
}
// Check constraints.
var diagnosticsBuilder = ArrayBuilder <TypeParameterDiagnosticInfo> .GetInstance();
var typeParams = method.TypeParameters;
var substitution = new TypeMap(typeParams, typeArgs);
ArrayBuilder <TypeParameterDiagnosticInfo> useSiteDiagnosticsBuilder = null;
var success = method.CheckConstraints(conversions, substitution, method.TypeParameters, typeArgs, compilation, diagnosticsBuilder, ref useSiteDiagnosticsBuilder);
diagnosticsBuilder.Free();
if (useSiteDiagnosticsBuilder != null && useSiteDiagnosticsBuilder.Count > 0)
{
if (useSiteDiagnostics == null)
{
useSiteDiagnostics = new HashSet <DiagnosticInfo>();
}
foreach (var diag in useSiteDiagnosticsBuilder)
{
useSiteDiagnostics.Add(diag.DiagnosticInfo);
}
}
if (!success)
{
return(null);
}
return(method.Construct(typeArgs));
}
/// <summary>
/// Tries to find candidate operators for a given operator name and
/// parameter list in the concepts in scope at this stage.
/// </summary>
/// <param name="name">
/// The special name of the operator to find.
/// </param>
/// <param name="args">
/// The arguments being supplied to the operator.
/// </param>
/// <param name="useSiteDiagnostics">
/// The set of diagnostics to populate with any use-site diagnostics
/// coming from this lookup.
/// </param>
/// <returns>
/// An array of possible matches for the given operator.
/// </returns>
private ImmutableArray <MethodSymbol> GetConceptOperators(string name, ImmutableArray <BoundExpression> args, ref HashSet <DiagnosticInfo> useSiteDiagnostics)
{
var builder = ArrayBuilder <MethodSymbol> .GetInstance();
var result = LookupResult.GetInstance();
// @t-mawind
// This is a fairly crude, and potentially very incorrect, method
// of finding overloads--can it be improved?
for (var scope = _binder; scope != null; scope = scope.Next)
{
var coptions = Binder.ConceptSearchOptions.SearchUsings |
Binder.ConceptSearchOptions.SearchContainers |
Binder.ConceptSearchOptions.NoConceptExtensions |
Binder.ConceptSearchOptions.AllowStandaloneInstances;
scope.LookupConceptMethodsInSingleBinder(result, name, 0, null, LookupOptions.AllMethodsOnArityZero | LookupOptions.AllowSpecialMethods, _binder, true, ref useSiteDiagnostics, coptions);
if (result.IsMultiViable)
{
var haveCandidates = false;
foreach (var candidate in result.Symbols)
{
if (candidate == null)
{
continue;
}
if (candidate.Kind != SymbolKind.Method)
{
continue;
}
var method = (MethodSymbol)candidate;
if (method.MethodKind != MethodKind.UserDefinedOperator)
{
continue;
}
if (method.ParameterCount != args.Length)
{
continue;
}
// @MattWindsor91 (Concept-C# 2017)
//
// Unlike normal operator overloads, concept operators
// will have missing type parameters: at the very least, the
// witness parameter telling us which concept instance to
// call into will be unknown.
//
// In this prototype, we just call a full round of method
// type inference, and ignore the method if it doesn't infer.
//
// This probably doesn't handle nullability correctly.
HashSet <DiagnosticInfo> ignore = null;
// As with MethodCompiler.BindMethodBody, we need to
// pull in the witnesses of a default struct into scope.
var mtr = MethodTypeInferrer.Infer(_binder, method.TypeParameters, method.ContainingType, method.ParameterTypes, method.ParameterRefKinds, args, ref ignore);
if (!mtr.Success)
{
continue;
}
haveCandidates = true;
if (method is SynthesizedImplicitConceptMethodSymbol imethod)
{
builder.Add(imethod.ConstructAndRetarget(mtr.InferredTypeArguments));
}
else
{
builder.Add(method.Construct(mtr.InferredTypeArguments));
}
}
// We're currently doing this fairly similarly to the way
// normal method lookup works: the moment any scope gives
// us at least one possible operator, use only that scope's
// results. I'm not sure whether this is correct, but at
// least it's consistent.
if (haveCandidates)
{
return(builder.ToImmutableAndFree());
}
}
}
// At this stage, we haven't seen _any_ operators.
builder.Free();
return(ImmutableArray <MethodSymbol> .Empty);
}
/// <summary>
/// If the extension method is applicable based on the "this" argument type, return
/// the method constructed with the inferred type arguments. If the method is not an
/// unconstructed generic method, type inference is skipped. If the method is not
/// applicable, or if constraints when inferring type parameters from the "this" type
/// are not satisfied, the return value is null.
/// </summary>
private static MethodSymbol InferExtensionMethodTypeArguments(MethodSymbol method, TypeSymbol thisType, ref HashSet <DiagnosticInfo> useSiteDiagnostics)
{
Debug.Assert(method.IsExtensionMethod);
Debug.Assert((object)thisType != null);
if (!method.IsGenericMethod || method != method.ConstructedFrom)
{
return(method);
}
// We never resolve extension methods on a dynamic receiver.
if (thisType.IsDynamic())
{
return(null);
}
var containingAssembly = method.ContainingAssembly;
var errorNamespace = containingAssembly.GlobalNamespace;
var conversions = new TypeConversions(containingAssembly.CorLibrary);
// There is absolutely no plausible syntax/tree that we could use for these
// synthesized literals. We could be speculatively binding a call to a PE method.
var syntaxTree = CSharpSyntaxTree.Dummy;
var syntax = (CSharpSyntaxNode)syntaxTree.GetRoot();
// Create an argument value for the "this" argument of specific type,
// and pass the same bad argument value for all other arguments.
var thisArgumentValue = new BoundLiteral(syntax, ConstantValue.Bad, thisType)
{
WasCompilerGenerated = true
};
var otherArgumentType = new ExtendedErrorTypeSymbol(errorNamespace, name: string.Empty, arity: 0, errorInfo: null, unreported: false);
var otherArgumentValue = new BoundLiteral(syntax, ConstantValue.Bad, otherArgumentType)
{
WasCompilerGenerated = true
};
var paramCount = method.ParameterCount;
var arguments = new BoundExpression[paramCount];
for (int i = 0; i < paramCount; i++)
{
var argument = (i == 0) ? thisArgumentValue : otherArgumentValue;
arguments[i] = argument;
}
var typeArgs = MethodTypeInferrer.InferTypeArgumentsFromFirstArgument(
conversions,
method,
arguments.AsImmutable(),
useSiteDiagnostics: ref useSiteDiagnostics);
if (typeArgs.IsDefault)
{
return(null);
}
// For the purpose of construction we use original type parameters in place of type arguments that we couldn't infer from the first argument.
ImmutableArray <TypeWithAnnotations> typeArgsForConstruct = typeArgs;
if (typeArgs.Any(t => !t.HasType))
{
typeArgsForConstruct = typeArgs.ZipAsArray(
method.TypeParameters,
(t, tp) => t.HasType ? t : TypeWithAnnotations.Create(tp));
}
return(method.Construct(typeArgsForConstruct));
}
