internal ExtendedErrorTypeSymbol(NamespaceOrTypeSymbol containingSymbol, ImmutableArray<Symbol> candidateSymbols, LookupResultKind resultKind, DiagnosticInfo errorInfo, int arity, bool unreported = false)
: this(containingSymbol, candidateSymbols[0].Name, arity, errorInfo, unreported)
{
_candidateSymbols = UnwrapErrorCandidates(candidateSymbols);
_resultKind = resultKind;
Debug.Assert(candidateSymbols.IsEmpty || resultKind != LookupResultKind.Viable, "Shouldn't use LookupResultKind.Viable with candidate symbols");
}
private BoundExpression MakeFieldAccess(
CSharpSyntaxNode syntax,
BoundExpression rewrittenReceiver,
FieldSymbol fieldSymbol,
ConstantValue constantValueOpt,
LookupResultKind resultKind,
TypeSymbol type,
BoundFieldAccess oldNodeOpt = null)
{
if (fieldSymbol.IsTupleField)
{
return MakeTupleFieldAccess(syntax, fieldSymbol, rewrittenReceiver, constantValueOpt, resultKind);
}
BoundExpression result = oldNodeOpt != null ?
oldNodeOpt.Update(rewrittenReceiver, fieldSymbol, constantValueOpt, resultKind, type) :
new BoundFieldAccess(syntax, rewrittenReceiver, fieldSymbol, constantValueOpt, resultKind, type);
if (fieldSymbol.IsFixed)
{
// a reference to a fixed buffer is translated into its address
result = new BoundConversion(syntax,
new BoundAddressOfOperator(syntax, result, syntax != null && SyntaxFacts.IsFixedStatementExpression(syntax), type, false),
new Conversion(ConversionKind.PointerToPointer), false, false, default(ConstantValue), type, false);
}
return result;
}
private LookupResult(ObjectPool<LookupResult> pool)
{
this.pool = pool;
this.kind = LookupResultKind.Empty;
this.symbolList = new ArrayBuilder<Symbol>();
this.error = null;
}
private void PopulateHelper(BoundExpression receiverOpt, LookupResultKind resultKind, DiagnosticInfo error)
{
VerifyClear();
this.Receiver = receiverOpt;
this.Error = error;
this.ResultKind = resultKind;
}
internal static SymbolInfo Create(ImmutableArray<Symbol> symbols, LookupResultKind resultKind, bool isDynamic)
{
if (isDynamic)
{
if (symbols.Length == 1)
{
return new SymbolInfo(symbols[0], CandidateReason.LateBound);
}
else
{
return new SymbolInfo(StaticCast<ISymbol>.From(symbols), CandidateReason.LateBound);
}
}
else if (resultKind == LookupResultKind.Viable)
{
if (symbols.Length > 0)
{
Debug.Assert(symbols.Length == 1);
return new SymbolInfo(symbols[0]);
}
else
{
return SymbolInfo.None;
}
}
else
{
return new SymbolInfo(StaticCast<ISymbol>.From(symbols), (symbols.Length > 0) ? resultKind.ToCandidateReason() : CandidateReason.None);
}
}
private LookupResult(ObjectPool<LookupResult> pool)
{
_pool = pool;
_kind = LookupResultKind.Empty;
_symbolList = new ArrayBuilder<Symbol>();
_error = null;
}
public MethodGroupResolution(
MethodGroup methodGroup,
Symbol otherSymbol,
OverloadResolutionResult<MethodSymbol> overloadResolutionResult,
AnalyzedArguments analyzedArguments,
LookupResultKind resultKind,
ImmutableArray<Diagnostic> diagnostics,
bool extensionMethodsOfSameViabilityAreAvailable)
{
Debug.Assert((methodGroup == null) || (methodGroup.Methods.Count > 0));
Debug.Assert((methodGroup == null) || ((object)otherSymbol == null));
// Methods should be represented in the method group.
Debug.Assert(((object)otherSymbol == null) || (otherSymbol.Kind != SymbolKind.Method));
Debug.Assert(resultKind != LookupResultKind.Ambiguous); // HasAnyApplicableMethod is expecting Viable methods.
Debug.Assert(!diagnostics.IsDefault);
Debug.Assert(!extensionMethodsOfSameViabilityAreAvailable || methodGroup == null || !methodGroup.IsExtensionMethodGroup);
this.MethodGroup = methodGroup;
this.OtherSymbol = otherSymbol;
this.OverloadResolutionResult = overloadResolutionResult;
this.AnalyzedArguments = analyzedArguments;
this.ResultKind = resultKind;
this.Diagnostics = diagnostics;
this.ExtensionMethodsOfSameViabilityAreAvailable = extensionMethodsOfSameViabilityAreAvailable;
}
internal void PopulateWithSingleMethod(
BoundExpression receiverOpt,
MethodSymbol method,
LookupResultKind resultKind = LookupResultKind.Viable,
DiagnosticInfo error = null)
{
this.PopulateHelper(receiverOpt, resultKind, error);
this.Methods.Add(method);
}
public BoundFieldAccess Update(
BoundExpression receiver,
FieldSymbol fieldSymbol,
ConstantValue constantValueOpt,
LookupResultKind resultKind,
TypeSymbol typeSymbol)
{
return this.Update(receiver, fieldSymbol, constantValueOpt, resultKind, this.IsByValue, typeSymbol);
}
private ExtendedErrorTypeSymbol(NamespaceOrTypeSymbol containingSymbol, string name, int arity, DiagnosticInfo errorInfo, bool unreported, bool variableUsedBeforeDeclaration, ImmutableArray<Symbol> candidateSymbols, LookupResultKind resultKind)
{
_name = name;
_errorInfo = errorInfo;
_containingSymbol = containingSymbol;
_arity = arity;
_unreported = unreported;
this.VariableUsedBeforeDeclaration = variableUsedBeforeDeclaration;
_candidateSymbols = candidateSymbols;
_resultKind = resultKind;
}
public void Clear()
{
this.Receiver = null;
this.Methods.Clear();
this.TypeArguments.Clear();
this.IsExtensionMethodGroup = false;
this.Error = null;
this.ResultKind = LookupResultKind.Empty;
VerifyClear();
}
public BoundFieldAccess(
CSharpSyntaxNode syntax,
BoundExpression receiver,
FieldSymbol fieldSymbol,
ConstantValue constantValueOpt,
LookupResultKind resultKind,
TypeSymbol type,
bool hasErrors = false)
: this(syntax, receiver, fieldSymbol, constantValueOpt, resultKind, NeedsByValueFieldAccess(receiver, fieldSymbol), type, hasErrors)
{
}
internal void PopulateWithNonExtensionMethods(
BoundExpression receiverOpt,
ImmutableArray<MethodSymbol> methods,
ImmutableArray<TypeSymbol> typeArguments,
LookupResultKind resultKind = LookupResultKind.Viable,
DiagnosticInfo error = null)
{
this.PopulateHelper(receiverOpt, resultKind, error);
this.Methods.AddRange(methods);
if (!typeArguments.IsDefault)
{
this.TypeArguments.AddRange(typeArguments);
}
}
internal ExtendedErrorTypeSymbol(NamespaceOrTypeSymbol containingSymbol, string name, int arity, DiagnosticInfo errorInfo, bool unreported = false, bool variableUsedBeforeDeclaration = false)
{
Debug.Assert(((object)containingSymbol == null) ||
(containingSymbol.Kind == SymbolKind.Namespace) ||
(containingSymbol.Kind == SymbolKind.NamedType) ||
(containingSymbol.Kind == SymbolKind.ErrorType));
Debug.Assert(name != null);
Debug.Assert(unreported == false || errorInfo != null);
_name = name;
_errorInfo = errorInfo;
_containingSymbol = containingSymbol;
_arity = arity;
_unreported = unreported;
this.VariableUsedBeforeDeclaration = variableUsedBeforeDeclaration;
_resultKind = LookupResultKind.Empty;
}
internal void PopulateWithExtensionMethods(
BoundExpression receiverOpt,
ArrayBuilder<Symbol> members,
ImmutableArray<TypeSymbol> typeArguments,
LookupResultKind resultKind = LookupResultKind.Viable,
DiagnosticInfo error = null)
{
this.PopulateHelper(receiverOpt, resultKind, error);
this.IsExtensionMethodGroup = true;
foreach (var member in members)
{
this.Methods.Add((MethodSymbol)member);
}
if (!typeArguments.IsDefault)
{
this.TypeArguments.AddRange(typeArguments);
}
}
/// <summary>
/// Converts access to a tuple instance into access into the underlying ValueTuple(s).
///
/// For instance, tuple.Item8
/// produces fieldAccess(field=Item1, receiver=fieldAccess(field=Rest, receiver=ValueTuple for tuple))
/// </summary>
private BoundExpression MakeTupleFieldAccess(
CSharpSyntaxNode syntax,
FieldSymbol tupleField,
BoundExpression rewrittenReceiver,
ConstantValue constantValueOpt,
LookupResultKind resultKind,
TypeSymbol type)
{
var tupleType = tupleField.ContainingType;
NamedTypeSymbol currentLinkType = tupleType.TupleUnderlyingType;
FieldSymbol underlyingField = tupleField.TupleUnderlyingField;
if ((object)underlyingField == null)
{
// Use-site error must have been reported elsewhere.
return new BoundFieldAccess(syntax, rewrittenReceiver, tupleField, constantValueOpt, resultKind, type, hasErrors: true);
}
if (underlyingField.ContainingType != currentLinkType)
{
WellKnownMember wellKnownTupleRest = TupleTypeSymbol.GetTupleTypeMember(TupleTypeSymbol.RestPosition, TupleTypeSymbol.RestPosition);
var tupleRestField = (FieldSymbol)TupleTypeSymbol.GetWellKnownMemberInType(currentLinkType.OriginalDefinition, wellKnownTupleRest, _diagnostics, syntax);
if ((object)tupleRestField == null)
{
// error tolerance for cases when Rest is missing
return new BoundFieldAccess(syntax, rewrittenReceiver, tupleField, constantValueOpt, resultKind, type, hasErrors: true);
}
// make nested field accesses to Rest
do
{
FieldSymbol nestedFieldSymbol = tupleRestField.AsMember(currentLinkType);
currentLinkType = currentLinkType.TypeArgumentsNoUseSiteDiagnostics[TupleTypeSymbol.RestPosition - 1].TupleUnderlyingType;
rewrittenReceiver = new BoundFieldAccess(syntax, rewrittenReceiver, nestedFieldSymbol, ConstantValue.NotAvailable, LookupResultKind.Viable, currentLinkType);
}
while (underlyingField.ContainingType != currentLinkType);
}
// make a field access for the most local access
return new BoundFieldAccess(syntax, rewrittenReceiver, underlyingField, constantValueOpt, resultKind, type);
}
private BoundExpression MakePropertyAccess(
SyntaxNode syntax,
BoundExpression rewrittenReceiverOpt,
PropertySymbol propertySymbol,
LookupResultKind resultKind,
TypeSymbol type,
bool isLeftOfAssignment,
BoundPropertyAccess oldNodeOpt = null)
{
// check for System.Array.[Length|LongLength] on a single dimensional array,
// we have a special node for such cases.
if (rewrittenReceiverOpt != null && rewrittenReceiverOpt.Type.IsArray() && !isLeftOfAssignment)
{
var asArrayType = (ArrayTypeSymbol)rewrittenReceiverOpt.Type;
if (asArrayType.IsSZArray)
{
// NOTE: we are not interested in potential badness of Array.Length property.
// If it is bad reference compare will not succeed.
if (ReferenceEquals(propertySymbol, _compilation.GetSpecialTypeMember(SpecialMember.System_Array__Length)) ||
!_inExpressionLambda && ReferenceEquals(propertySymbol, _compilation.GetSpecialTypeMember(SpecialMember.System_Array__LongLength)))
{
return new BoundArrayLength(syntax, rewrittenReceiverOpt, type);
}
}
}
if (isLeftOfAssignment && propertySymbol.RefKind == RefKind.None)
{
// This is a property set access. We return a BoundPropertyAccess node here.
// This node will be rewritten with MakePropertyAssignment when rewriting the enclosing BoundAssignmentOperator.
return oldNodeOpt != null ?
oldNodeOpt.Update(rewrittenReceiverOpt, propertySymbol, resultKind, type) :
new BoundPropertyAccess(syntax, rewrittenReceiverOpt, propertySymbol, resultKind, type);
}
else
{
// This is a property get access
return MakePropertyGetAccess(syntax, rewrittenReceiverOpt, propertySymbol, oldNodeOpt);
}
}
public static BoundCall ErrorCall(
CSharpSyntaxNode node,
BoundExpression receiverOpt,
MethodSymbol method,
ImmutableArray<BoundExpression> arguments,
ImmutableArray<string> namedArguments,
ImmutableArray<RefKind> refKinds,
bool isDelegateCall,
bool invokedAsExtensionMethod,
ImmutableArray<MethodSymbol> originalMethods,
LookupResultKind resultKind)
{
if (!originalMethods.IsEmpty)
resultKind = resultKind.WorseResultKind(LookupResultKind.OverloadResolutionFailure);
var call = new BoundCall(node, receiverOpt, method, arguments, namedArguments,
refKinds, isDelegateCall: isDelegateCall, expanded: false, invokedAsExtensionMethod: invokedAsExtensionMethod, argsToParamsOpt: default(ImmutableArray<int>),
resultKind: resultKind, type: method.ReturnType, hasErrors: true);
call.OriginalMethodsOpt = originalMethods;
return call;
}
public BoundUserDefinedConditionalLogicalOperator(
CSharpSyntaxNode syntax,
BinaryOperatorKind operatorKind,
BoundExpression left,
BoundExpression right,
MethodSymbol logicalOperator,
MethodSymbol trueOperator,
MethodSymbol falseOperator,
LookupResultKind resultKind,
ImmutableArray<MethodSymbol> originalUserDefinedOperatorsOpt,
TypeSymbol type,
bool hasErrors = false)
: this(
syntax,
operatorKind,
left,
right,
logicalOperator,
trueOperator,
falseOperator,
resultKind,
type,
hasErrors)
{
Debug.Assert(operatorKind.IsUserDefined() && operatorKind.IsLogical());
this.OriginalUserDefinedOperatorsOpt = originalUserDefinedOperatorsOpt;
}
public BoundCompoundAssignmentOperator(
CSharpSyntaxNode syntax,
BinaryOperatorSignature @operator,
BoundExpression left,
BoundExpression right,
Conversion leftConversion,
Conversion finalConversion,
LookupResultKind resultKind,
ImmutableArray<MethodSymbol> originalUserDefinedOperatorsOpt,
TypeSymbol type,
bool hasErrors = false)
: this(
syntax,
@operator,
left,
right,
leftConversion,
finalConversion,
resultKind,
type,
hasErrors)
{
this.OriginalUserDefinedOperatorsOpt = originalUserDefinedOperatorsOpt;
}
public MethodGroupResolution(Symbol otherSymbol, LookupResultKind resultKind, ImmutableArray <Diagnostic> diagnostics)
: this(null, otherSymbol, null, null, resultKind, diagnostics)
{
}
public static LookupResultKind WorseResultKind(this LookupResultKind resultKind1, LookupResultKind resultKind2)
{
if (resultKind1 == LookupResultKind.Empty)
{
return(resultKind2);
}
if (resultKind2 == LookupResultKind.Empty)
{
return(resultKind1);
}
if (resultKind1 < resultKind2)
{
return(resultKind1);
}
else
{
return(resultKind2);
}
}
private UnaryOperatorAnalysisResult UnaryOperatorOverloadResolution(
UnaryOperatorKind kind,
BoundExpression operand,
CSharpSyntaxNode node,
DiagnosticBag diagnostics,
out LookupResultKind resultKind,
out ImmutableArray<MethodSymbol> originalUserDefinedOperators)
{
var result = UnaryOperatorOverloadResolutionResult.GetInstance();
HashSet<DiagnosticInfo> useSiteDiagnostics = null;
this.OverloadResolution.UnaryOperatorOverloadResolution(kind, operand, result, ref useSiteDiagnostics);
diagnostics.Add(node, useSiteDiagnostics);
var possiblyBest = result.Best;
if (result.Results.Any())
{
var builder = ArrayBuilder<MethodSymbol>.GetInstance();
foreach (var analysisResult in result.Results)
{
MethodSymbol method = analysisResult.Signature.Method;
if ((object)method != null)
{
builder.Add(method);
}
}
originalUserDefinedOperators = builder.ToImmutableAndFree();
if (possiblyBest.HasValue)
{
resultKind = LookupResultKind.Viable;
}
else if (result.AnyValid())
{
// Special case: If we have the unary minus operator applied to a ulong, technically that should be
// an ambiguity. The ulong could be implicitly converted to float, double or decimal, and then
// the unary minus operator could be applied to the result. But though float is better than double,
// float is neither better nor worse than decimal. However it seems odd to give an ambiguity error
// when trying to do something such as applying a unary minus operator to an unsigned long.
if (kind == UnaryOperatorKind.UnaryMinus &&
(object)operand.Type != null &&
operand.Type.SpecialType == SpecialType.System_UInt64)
{
resultKind = LookupResultKind.OverloadResolutionFailure;
}
else
{
resultKind = LookupResultKind.Ambiguous;
}
}
else
{
resultKind = LookupResultKind.OverloadResolutionFailure;
}
}
else
{
originalUserDefinedOperators = ImmutableArray<MethodSymbol>.Empty;
resultKind = possiblyBest.HasValue ? LookupResultKind.Viable : LookupResultKind.Empty;
}
if (possiblyBest.HasValue &&
(object)possiblyBest.Signature.Method != null)
{
Symbol symbol = possiblyBest.Signature.Method;
ReportDiagnosticsIfObsolete(diagnostics, symbol, node, hasBaseReceiver: false);
}
result.Free();
return possiblyBest;
}
private void ReportAssignmentOperatorError(AssignmentExpressionSyntax node, DiagnosticBag diagnostics, BoundExpression left, BoundExpression right, LookupResultKind resultKind)
{
if (((SyntaxKind)node.OperatorToken.RawKind == SyntaxKind.PlusEqualsToken || (SyntaxKind)node.OperatorToken.RawKind == SyntaxKind.MinusEqualsToken) &&
(object)left.Type != null && left.Type.TypeKind == TypeKind.Delegate)
{
// Special diagnostic for delegate += and -= about wrong right-hand-side
HashSet<DiagnosticInfo> useSiteDiagnostics = null;
var conversion = this.Conversions.ClassifyConversionFromExpression(right, left.Type, ref useSiteDiagnostics);
Debug.Assert(!conversion.IsImplicit);
GenerateImplicitConversionError(diagnostics, right.Syntax, conversion, right, left.Type);
// discard use-site diagnostics
}
else
{
ReportBinaryOperatorError(node, diagnostics, node.OperatorToken, left, right, resultKind);
}
}
private ExtendedErrorTypeSymbol(NamespaceOrTypeSymbol containingSymbol, string name, int arity, DiagnosticInfo errorInfo, bool unreported, bool variableUsedBeforeDeclaration, ImmutableArray <Symbol> candidateSymbols, LookupResultKind resultKind)
{
_name = name;
_errorInfo = errorInfo;
_containingSymbol = containingSymbol;
_arity = arity;
_unreported = unreported;
this.VariableUsedBeforeDeclaration = variableUsedBeforeDeclaration;
_candidateSymbols = candidateSymbols;
_resultKind = resultKind;
}
public MethodGroupResolution(Symbol otherSymbol, LookupResultKind resultKind, ImmutableArray<Diagnostic> diagnostics)
: this(null, otherSymbol, null, null, resultKind, diagnostics)
{
}
internal ExtendedErrorTypeSymbol(NamespaceOrTypeSymbol containingSymbol, Symbol guessSymbol, LookupResultKind resultKind, DiagnosticInfo errorInfo, bool unreported = false)
: this(containingSymbol, ImmutableArray.Create <Symbol>(guessSymbol), resultKind, errorInfo, GetArity(guessSymbol), unreported)
{
}
internal ExtendedErrorTypeSymbol(NamespaceOrTypeSymbol guessSymbol, LookupResultKind resultKind, DiagnosticInfo errorInfo, bool unreported = false)
: this(guessSymbol.ContainingNamespaceOrType(), guessSymbol, resultKind, errorInfo, unreported)
{
}
internal ExtendedErrorTypeSymbol(NamespaceOrTypeSymbol containingSymbol, ImmutableArray <Symbol> candidateSymbols, LookupResultKind resultKind, DiagnosticInfo errorInfo, int arity, bool unreported = false)
: this(containingSymbol, candidateSymbols[0].Name, arity, errorInfo, unreported)
{
_candidateSymbols = UnwrapErrorCandidates(candidateSymbols);
_resultKind = resultKind;
Debug.Assert(candidateSymbols.IsEmpty || resultKind != LookupResultKind.Viable, "Shouldn't use LookupResultKind.Viable with candidate symbols");
}
private BoundExpression MakeCall(
BoundCall node,
CSharpSyntaxNode syntax,
BoundExpression rewrittenReceiver,
MethodSymbol method,
ImmutableArray <BoundExpression> rewrittenArguments,
ImmutableArray <RefKind> argumentRefKinds,
bool invokedAsExtensionMethod,
LookupResultKind resultKind,
TypeSymbol type,
ImmutableArray <LocalSymbol> temps = default(ImmutableArray <LocalSymbol>))
{
BoundExpression rewrittenBoundCall;
if (method.IsStatic &&
method.ContainingType.IsObjectType() &&
!inExpressionLambda &&
(object)method == (object)this.compilation.GetSpecialTypeMember(SpecialMember.System_Object__ReferenceEquals))
{
Debug.Assert(rewrittenArguments.Length == 2);
// ECMA - 335
// I.8.2.5.1 Identity
// ...
// Identity is implemented on System.Object via the ReferenceEquals method.
rewrittenBoundCall = new BoundBinaryOperator(
syntax,
BinaryOperatorKind.ObjectEqual,
rewrittenArguments[0],
rewrittenArguments[1],
null,
null,
resultKind,
type);
}
else if (node == null)
{
rewrittenBoundCall = new BoundCall(
syntax,
rewrittenReceiver,
method,
rewrittenArguments,
default(ImmutableArray <string>),
argumentRefKinds,
isDelegateCall: false,
expanded: false,
invokedAsExtensionMethod: invokedAsExtensionMethod,
argsToParamsOpt: default(ImmutableArray <int>),
resultKind: resultKind,
type: type);
}
else
{
rewrittenBoundCall = node.Update(
rewrittenReceiver,
method,
rewrittenArguments,
default(ImmutableArray <string>),
argumentRefKinds,
node.IsDelegateCall,
false,
node.InvokedAsExtensionMethod,
default(ImmutableArray <int>),
node.ResultKind,
node.Type);
}
if (!temps.IsDefaultOrEmpty)
{
return(new BoundSequence(
syntax,
locals: temps,
sideEffects: ImmutableArray <BoundExpression> .Empty,
value: rewrittenBoundCall,
type: type));
}
return(rewrittenBoundCall);
}
private Symbol BindNamedAttributeArgumentName(AttributeArgumentSyntax namedArgument, NamedTypeSymbol attributeType, DiagnosticBag diagnostics, out bool wasError, out LookupResultKind resultKind)
{
var identifierName = namedArgument.NameEquals.Name;
var name = identifierName.Identifier.ValueText;
LookupResult result = LookupResult.GetInstance();
HashSet<DiagnosticInfo> useSiteDiagnostics = null;
this.LookupMembersWithFallback(result, attributeType, name, 0, ref useSiteDiagnostics);
diagnostics.Add(identifierName, useSiteDiagnostics);
Symbol resultSymbol = this.ResultSymbol(result, name, 0, identifierName, diagnostics, false, out wasError);
resultKind = result.Kind;
result.Free();
return resultSymbol;
}
public BoundBadExpression(CSharpSyntaxNode syntax, LookupResultKind resultKind, ImmutableArray<Symbol> symbols, ImmutableArray<BoundNode> childBoundNodes, TypeSymbol type)
: this(syntax, resultKind, symbols, childBoundNodes, type, true)
{
Debug.Assert((object)type != null);
}
public void Clear()
{
_kind = LookupResultKind.Empty;
_symbolList.Clear();
_error = null;
}
private BoundExpression MakeEventAccess(
SyntaxNode syntax,
BoundExpression rewrittenReceiver,
EventSymbol eventSymbol,
ConstantValue constantValueOpt,
LookupResultKind resultKind,
TypeSymbol type)
{
Debug.Assert(eventSymbol.HasAssociatedField);
FieldSymbol fieldSymbol = eventSymbol.AssociatedField;
Debug.Assert((object)fieldSymbol != null);
if (!eventSymbol.IsWindowsRuntimeEvent)
{
return MakeFieldAccess(syntax, rewrittenReceiver, fieldSymbol, constantValueOpt, resultKind, type);
}
NamedTypeSymbol fieldType = (NamedTypeSymbol)fieldSymbol.Type;
Debug.Assert(fieldType.Name == "EventRegistrationTokenTable");
// _tokenTable
BoundFieldAccess fieldAccess = new BoundFieldAccess(
syntax,
fieldSymbol.IsStatic ? null : rewrittenReceiver,
fieldSymbol,
constantValueOpt: null)
{ WasCompilerGenerated = true };
BoundExpression getOrCreateCall;
MethodSymbol getOrCreateMethod;
if (TryGetWellKnownTypeMember(syntax, WellKnownMember.System_Runtime_InteropServices_WindowsRuntime_EventRegistrationTokenTable_T__GetOrCreateEventRegistrationTokenTable, out getOrCreateMethod))
{
getOrCreateMethod = getOrCreateMethod.AsMember(fieldType);
// EventRegistrationTokenTable<Event>.GetOrCreateEventRegistrationTokenTable(ref _tokenTable)
getOrCreateCall = BoundCall.Synthesized(
syntax,
receiverOpt: null,
method: getOrCreateMethod,
arg0: fieldAccess);
}
else
{
getOrCreateCall = new BoundBadExpression(syntax, LookupResultKind.NotInvocable, ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundNode>(fieldAccess), ErrorTypeSymbol.UnknownResultType);
}
PropertySymbol invocationListProperty;
if (TryGetWellKnownTypeMember(syntax, WellKnownMember.System_Runtime_InteropServices_WindowsRuntime_EventRegistrationTokenTable_T__InvocationList, out invocationListProperty))
{
MethodSymbol invocationListAccessor = invocationListProperty.GetMethod;
if ((object)invocationListAccessor == null)
{
string accessorName = SourcePropertyAccessorSymbol.GetAccessorName(invocationListProperty.Name,
getNotSet: true,
isWinMdOutput: invocationListProperty.IsCompilationOutputWinMdObj());
_diagnostics.Add(new CSDiagnosticInfo(ErrorCode.ERR_MissingPredefinedMember, invocationListProperty.ContainingType, accessorName), syntax.Location);
}
else
{
invocationListAccessor = invocationListAccessor.AsMember(fieldType);
return _factory.Call(getOrCreateCall, invocationListAccessor);
}
}
return new BoundBadExpression(syntax, LookupResultKind.NotInvocable, ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundNode>(getOrCreateCall), ErrorTypeSymbol.UnknownResultType);
}
private BoundExpression MakeEventAccess(
SyntaxNode syntax,
BoundExpression rewrittenReceiver,
EventSymbol eventSymbol,
ConstantValue constantValueOpt,
LookupResultKind resultKind,
TypeSymbol type)
{
Debug.Assert(eventSymbol.HasAssociatedField);
FieldSymbol fieldSymbol = eventSymbol.AssociatedField;
Debug.Assert((object)fieldSymbol != null);
if (!eventSymbol.IsWindowsRuntimeEvent)
{
return(MakeFieldAccess(syntax, rewrittenReceiver, fieldSymbol, constantValueOpt, resultKind, type));
}
NamedTypeSymbol fieldType = (NamedTypeSymbol)fieldSymbol.Type.TypeSymbol;
Debug.Assert(fieldType.Name == "EventRegistrationTokenTable");
// _tokenTable
BoundFieldAccess fieldAccess = new BoundFieldAccess(
syntax,
fieldSymbol.IsStatic ? null : rewrittenReceiver,
fieldSymbol,
constantValueOpt: null)
{
WasCompilerGenerated = true
};
BoundExpression getOrCreateCall;
MethodSymbol getOrCreateMethod;
if (TryGetWellKnownTypeMember(syntax, WellKnownMember.System_Runtime_InteropServices_WindowsRuntime_EventRegistrationTokenTable_T__GetOrCreateEventRegistrationTokenTable, out getOrCreateMethod))
{
getOrCreateMethod = getOrCreateMethod.AsMember(fieldType);
// EventRegistrationTokenTable<Event>.GetOrCreateEventRegistrationTokenTable(ref _tokenTable)
getOrCreateCall = BoundCall.Synthesized(
syntax,
receiverOpt: null,
method: getOrCreateMethod,
arg0: fieldAccess);
}
else
{
getOrCreateCall = new BoundBadExpression(syntax, LookupResultKind.NotInvocable, ImmutableArray <Symbol> .Empty, ImmutableArray.Create <BoundExpression>(fieldAccess), ErrorTypeSymbol.UnknownResultType);
}
PropertySymbol invocationListProperty;
if (TryGetWellKnownTypeMember(syntax, WellKnownMember.System_Runtime_InteropServices_WindowsRuntime_EventRegistrationTokenTable_T__InvocationList, out invocationListProperty))
{
MethodSymbol invocationListAccessor = invocationListProperty.GetMethod;
if ((object)invocationListAccessor == null)
{
string accessorName = SourcePropertyAccessorSymbol.GetAccessorName(invocationListProperty.Name,
getNotSet: true,
isWinMdOutput: invocationListProperty.IsCompilationOutputWinMdObj());
_diagnostics.Add(new CSDiagnosticInfo(ErrorCode.ERR_MissingPredefinedMember, invocationListProperty.ContainingType, accessorName), syntax.Location);
}
else
{
invocationListAccessor = invocationListAccessor.AsMember(fieldType);
return(_factory.Call(getOrCreateCall, invocationListAccessor));
}
}
return(new BoundBadExpression(syntax, LookupResultKind.NotInvocable, ImmutableArray <Symbol> .Empty, ImmutableArray.Create(getOrCreateCall), ErrorTypeSymbol.UnknownResultType));
}
private BinaryOperatorAnalysisResult BinaryOperatorOverloadResolution(BinaryOperatorKind kind, BoundExpression left, BoundExpression right, CSharpSyntaxNode node, DiagnosticBag diagnostics, out LookupResultKind resultKind, out ImmutableArray<MethodSymbol> originalUserDefinedOperators)
{
var result = BinaryOperatorOverloadResolutionResult.GetInstance();
HashSet<DiagnosticInfo> useSiteDiagnostics = null;
this.OverloadResolution.BinaryOperatorOverloadResolution(kind, left, right, result, ref useSiteDiagnostics);
diagnostics.Add(node, useSiteDiagnostics);
var possiblyBest = result.Best;
if (result.Results.Any())
{
var builder = ArrayBuilder<MethodSymbol>.GetInstance();
foreach (var analysisResult in result.Results)
{
MethodSymbol method = analysisResult.Signature.Method;
if ((object)method != null)
{
builder.Add(method);
}
}
originalUserDefinedOperators = builder.ToImmutableAndFree();
if (possiblyBest.HasValue)
{
resultKind = LookupResultKind.Viable;
}
else if (result.AnyValid())
{
resultKind = LookupResultKind.Ambiguous;
}
else
{
resultKind = LookupResultKind.OverloadResolutionFailure;
}
}
else
{
originalUserDefinedOperators = ImmutableArray<MethodSymbol>.Empty;
resultKind = possiblyBest.HasValue ? LookupResultKind.Viable : LookupResultKind.Empty;
}
if (possiblyBest.HasValue &&
(object)possiblyBest.Signature.Method != null)
{
Symbol symbol = possiblyBest.Signature.Method;
ReportDiagnosticsIfObsolete(diagnostics, symbol, node, hasBaseReceiver: false);
}
result.Free();
return possiblyBest;
}
public MethodGroupResolution(Symbol otherSymbol, LookupResultKind resultKind, ImmutableBindingDiagnostic <AssemblySymbol> diagnostics)
: this(methodGroup : null, otherSymbol, overloadResolutionResult : null, analyzedArguments : null, resultKind, diagnostics)
{
}
private static void ReportUnaryOperatorError(CSharpSyntaxNode node, DiagnosticBag diagnostics, string operatorName, BoundExpression operand, LookupResultKind resultKind)
{
ErrorCode errorCode = resultKind == LookupResultKind.Ambiguous ?
ErrorCode.ERR_AmbigUnaryOp : // Operator '{0}' is ambiguous on an operand of type '{1}'
ErrorCode.ERR_BadUnaryOp; // Operator '{0}' cannot be applied to operand of type '{1}'
Error(diagnostics, errorCode, node, operatorName, operand.Display);
}
internal SingleLookupResult(LookupResultKind kind, Symbol symbol, DiagnosticInfo error)
{
this.Kind = kind;
this.Symbol = symbol;
this.Error = error;
}
private static void ReportBinaryOperatorError(ExpressionSyntax node, DiagnosticBag diagnostics, SyntaxToken operatorToken, BoundExpression left, BoundExpression right, LookupResultKind resultKind)
{
ErrorCode errorCode = resultKind == LookupResultKind.Ambiguous ?
ErrorCode.ERR_AmbigBinaryOps : // Operator '{0}' is ambiguous on operands of type '{1}' and '{2}'
ErrorCode.ERR_BadBinaryOps; // Operator '{0}' cannot be applied to operands of type '{1}' and '{2}'
Error(diagnostics, errorCode, node, operatorToken.Text, left.Display, right.Display);
}
public BoundBadExpression(SyntaxNode syntax, LookupResultKind resultKind, ImmutableArray <Symbol> symbols, ImmutableArray <BoundExpression> childBoundNodes, TypeSymbol type)
: this(syntax, resultKind, symbols, childBoundNodes, type, true)
{
Debug.Assert((object)type != null);
}
protected virtual MethodSymbol BindAttributeConstructor(
AttributeSyntax node,
NamedTypeSymbol attributeType,
AnalyzedArguments boundConstructorArguments,
DiagnosticBag diagnostics,
ref LookupResultKind resultKind,
bool suppressErrors,
ref HashSet<DiagnosticInfo> useSiteDiagnostics)
{
MemberResolutionResult<MethodSymbol> memberResolutionResult;
ImmutableArray<MethodSymbol> candidateConstructors;
if (!TryPerformConstructorOverloadResolution(
attributeType,
boundConstructorArguments,
attributeType.Name,
node.Location,
suppressErrors, //don't cascade in these cases
diagnostics,
out memberResolutionResult,
out candidateConstructors,
allowProtectedConstructorsOfBaseType: true))
{
resultKind = resultKind.WorseResultKind(
memberResolutionResult.IsValid && !IsConstructorAccessible(memberResolutionResult.Member, ref useSiteDiagnostics) ?
LookupResultKind.Inaccessible :
LookupResultKind.OverloadResolutionFailure);
}
return memberResolutionResult.Member;
}
private bool IsMethodInvalid(LookupResultKind resultKind, MethodSymbol targetMethod) => resultKind == LookupResultKind.OverloadResolutionFailure || targetMethod?.OriginalDefinition is ErrorMethodSymbol;
