protected override ReadOnlyArray<ParameterSymbol> MakeParameters(
Binder binder,
DelegateDeclarationSyntax syntax,
out bool isExtensionMethod,
out bool isVararg,
DiagnosticBag diagnostics,
CancellationToken cancellationToken)
{
isExtensionMethod = false;
isVararg = false;
var delegateBinder = binder as DelegateBinder;
var parameters = ArrayBuilder<ParameterSymbol>.GetInstance();
int ordinal = 0;
foreach (var p in delegateBinder.invoke.Parameters)
{
cancellationToken.ThrowIfCancellationRequested();
if (p.RefKind != RefKind.None)
{
parameters.Add(new SynthesizedParameterSymbol(this, p.Type, ordinal++, p.RefKind, p.Name));
}
}
parameters.Add(new SynthesizedParameterSymbol(this, binder.GetSpecialType(SpecialType.System_IAsyncResult, diagnostics, syntax), ordinal++, RefKind.None, "result"));
return parameters.ToReadOnlyAndFree();
}
internal DelegateConstructor(
SourceNamedTypeSymbol delegateType,
DelegateDeclarationSyntax syntax,
Binder binder,
CancellationToken cancellationToken)
: base(delegateType, CommonMemberNames.InstanceConstructorName, syntax, MethodKind.Constructor, DeclarationModifiers.Public, binder, diagnostics: null, cancellationToken: cancellationToken)
{
}
internal FieldMemberBuilder(NamedTypeSymbol owner, Binder enclosing, FieldDeclarationSyntax declaration, TypeSymbol type, VariableDeclaratorSyntax declarator)
: base(enclosing.Location(declarator) as SourceLocation, owner, enclosing)
{
this.owner = owner;
this.declaration = declaration;
this.declarator = declarator;
this.Type = type;
}
protected override ReadOnlyArray<ParameterSymbol> MakeParameters(Binder binder, DelegateDeclarationSyntax syntax, out bool isExtensionMethod, out bool isVararg, DiagnosticBag diagnostics, CancellationToken cancellationToken)
{
isExtensionMethod = false;
isVararg = false;
return ReadOnlyArray<ParameterSymbol>.CreateFrom(
new SynthesizedParameterSymbol(this, binder.GetSpecialType(SpecialType.System_Object, diagnostics, syntax), 0, RefKind.None, "object"),
new SynthesizedParameterSymbol(this, binder.GetSpecialType(SpecialType.System_IntPtr, diagnostics, syntax), 1, RefKind.None, "method"));
}
protected override ReadOnlyArray<ParameterSymbol> MakeParameters(
Binder binder, DelegateDeclarationSyntax syntax,
out bool isExtensionMethod,
out bool isVararg,
DiagnosticBag diagnostics,
CancellationToken cancellationToken)
{
return MakeParameters(binder, syntax.ParameterList, out isExtensionMethod, out isVararg, diagnostics, cancellationToken);
}
internal DelegateInvokeMethodImplementation(
SourceNamedTypeSymbol delegateType,
DelegateDeclarationSyntax syntax,
Binder binder,
DiagnosticBag diagnostics,
CancellationToken cancellationToken)
: base(delegateType, CommonMemberNames.DelegateInvokeName, syntax, MethodKind.DelegateInvoke, DeclarationModifiers.Virtual | DeclarationModifiers.Public, binder, diagnostics, cancellationToken)
{
}
internal QualifiedNameBinder(NamespaceOrTypeSymbol qualifier, Binder outer)
: base(qualifier, new BuckStopsHereBinder(outer.Compilation, outer.SourceTree))
{
if (outer == null || qualifier == null)
throw new ArgumentNullException();
this.ambient = outer;
this.qualifier = qualifier;
}
internal override Binder CreateBinder(Binder next)
{
if (hasHostObject)
{
next = new HostObjectModelBinder(next);
}
if (previousInteraction != null)
{
next = new ChainedCompilationsBinder(previousInteraction, next);
}
return next;
}
protected DelegateMethodSymbol(
SourceNamedTypeSymbol containingType,
DelegateDeclarationSyntax syntax,
MethodKind methodKind,
DeclarationModifiers declarationModifiers,
Binder binder,
DiagnosticBag diagnostics)
: base(containingType, binder.GetSyntaxReference(syntax), blockSyntaxReference: null, location: binder.Location(syntax.Identifier))
{
this.parameters = MakeParameters(binder, syntax, diagnostics);
this.returnType = MakeReturnType(binder, syntax, diagnostics);
this.flags = MakeFlags(methodKind, declarationModifiers, this.returnType.SpecialType == SpecialType.System_Void, isExtensionMethod: false);
var info = ModifierUtils.CheckAccessibility(this.DeclarationModifiers);
if (info != null)
{
diagnostics.Add(info, this.locations[0]);
}
}
protected override ReadOnlyArray<ParameterSymbol> MakeParameters(
Binder binder,
DelegateDeclarationSyntax syntax,
out bool isExtensionMethod,
out bool isVararg,
DiagnosticBag diagnostics,
CancellationToken cancellationToken)
{
isExtensionMethod = false;
isVararg = false;
var delegateBinder = binder as DelegateBinder;
var parameters = ArrayBuilder<ParameterSymbol>.GetInstance();
foreach (var p in delegateBinder.invoke.Parameters)
{
cancellationToken.ThrowIfCancellationRequested();
parameters.Add(new SynthesizedParameterSymbol(this, p.Type, p.Ordinal, p.RefKind, p.Name));
}
parameters.Add(new SynthesizedParameterSymbol(this, binder.GetSpecialType(SpecialType.System_AsyncCallback, diagnostics, syntax), delegateBinder.invoke.Parameters.Count, RefKind.None, "callback"));
parameters.Add(new SynthesizedParameterSymbol(this, binder.GetSpecialType(SpecialType.System_Object, diagnostics, syntax), delegateBinder.invoke.Parameters.Count + 1, RefKind.None, "object"));
return parameters.ToReadOnlyAndFree();
}
protected DelegateMethodSymbol(
SourceNamedTypeSymbol containingType,
string name,
DelegateDeclarationSyntax syntax,
MethodKind methodKind,
DeclarationModifiers declarationModifiers,
Binder binder,
DiagnosticBag diagnostics,
CancellationToken cancellationToken)
: base(containingType, name, binder.GetSyntaxReference(syntax), blockSyntax: null, location: binder.Location(syntax.Identifier))
{
var location = this.locations[0];
bool isExtensionMethod;
this.parameters = MakeParameters(binder, syntax, out isExtensionMethod, out this.isVararg, diagnostics, cancellationToken);
this.returnType = MakeReturnType(binder, syntax, diagnostics);
this.flags = MakeFlags(methodKind, declarationModifiers, IsVoidType(this.returnType), isExtensionMethod: isExtensionMethod);
var info = ModifierUtils.CheckAccessibility(this.DeclarationModifiers);
if (info != null)
{
diagnostics.Add(info, location);
}
}
protected override ReadOnlyArray<ParameterSymbol> MakeParameters(Binder binder, DelegateDeclarationSyntax syntax, DiagnosticBag diagnostics)
{
return ReadOnlyArray<ParameterSymbol>.CreateFrom(
new SynthesizedParameterSymbol(this, binder.GetSpecialType(SpecialType.System_Object, diagnostics, syntax), 0, RefKind.None, "object"),
new SynthesizedParameterSymbol(this, binder.GetSpecialType(SpecialType.System_IntPtr, diagnostics, syntax), 1, RefKind.None, "method"));
}
internal DelegateConstructor(
SourceNamedTypeSymbol delegateType,
DelegateDeclarationSyntax syntax,
Binder binder)
: base(delegateType, syntax, MethodKind.Constructor, DeclarationModifiers.Public, binder, diagnostics: null)
{
}
protected override ReadOnlyArray<ParameterSymbol> MakeParameters(
Binder binder,
DelegateDeclarationSyntax syntax,
DiagnosticBag diagnostics)
{
var delegateBinder = binder as DelegateBinder;
var parameters = ArrayBuilder<ParameterSymbol>.GetInstance();
int ordinal = 0;
foreach (SourceParameterSymbol p in delegateBinder.invoke.Parameters)
{
if (p.RefKind != RefKind.None)
{
var synthesizedParam = new SourceClonedParameterSymbol(originalParam: p, newOwner: this, newOrdinal: ordinal++, suppressOptional: true);
parameters.Add(synthesizedParam);
}
}
parameters.Add(new SynthesizedParameterSymbol(this, binder.GetSpecialType(SpecialType.System_IAsyncResult, diagnostics, syntax), ordinal++, RefKind.None, "result"));
return parameters.ToReadOnlyAndFree();
}
protected abstract TypeSymbol MakeReturnType(Binder binder, DelegateDeclarationSyntax syntax, DiagnosticBag diagnostics);
protected abstract ReadOnlyArray<ParameterSymbol> MakeParameters(Binder binder, DelegateDeclarationSyntax syntax, out bool isExtensionMethod, out bool isVararg, DiagnosticBag diagnostics, CancellationToken cancellationToken);
private MethodMemberBuilder(NamedTypeSymbol container, Binder enclosing, MemberDeclarationSyntax syntax, DiagnosticBag diagnostics)
: base(enclosing.Location(syntax) as SourceLocation, container, enclosing)
{
Debug.Assert(syntax != null);
this.syntax = syntax;
// Make a binder context in which each type parameter binds to a corresponding numbered type parameter
Binder parametersContext = Enclosing;
if (syntax.Kind == SyntaxKind.MethodDeclaration)
{
var methodSyntax = syntax as MethodDeclarationSyntax;
int arity = methodSyntax.Arity;
if (arity != 0)
{
var typeParamMap = new MultiDictionary<string, TypeParameterSymbol>();
var typeParams = methodSyntax.TypeParameterListOpt.Parameters;
for (int iParam = 0; iParam < typeParams.Count; iParam++)
{
var arg = typeParams[iParam];
var symbol = IndexedTypeParameterSymbol.GetTypeParameter(iParam);
typeParamMap.Add(arg.Identifier.ValueText, symbol);
}
parametersContext = new WithDummyTypeParametersBinder(typeParamMap, Enclosing);
}
if (methodSyntax.ExplicitInterfaceSpecifierOpt != null)
{
this.explicitInterfaceType = enclosing.BindType(methodSyntax.ExplicitInterfaceSpecifierOpt.Name, diagnostics);
}
}
// TODOngafter 1: recast this code using ReadOnlyArray.
IEnumerable<ParameterSyntax> parameters = SyntaxParameters.HasValue ? SyntaxParameters.Value : SpecializedCollections.EmptyEnumerable<ParameterSyntax>();
declaredParameterTypes = parameters.Select(p =>
{
if (p.TypeOpt == null)
return new CSErrorTypeSymbol(enclosing.Compilation.GlobalNamespace, "ErrorType", 0, diagnostics.Add(ErrorCode.ERR_NotYetImplementedInRoslyn, new SourceLocation(Tree, p)));
return parametersContext.BindType(p.TypeOpt, diagnostics);
}).ToList();
var parameterRefs = parameters.Select(p => p.Modifiers.GetRefKind()).ToList();
switch (syntax.Kind)
{
case SyntaxKind.ConstructorDeclaration:
Binder original = parametersContext; // TODOngafter 1: worry about diagnostic reporting and suppression here.
declaredReturnType = Enclosing.GetSpecialType(SpecialType.System_Void, diagnostics, syntax);
break;
default:
declaredReturnType = parametersContext.BindType(SyntaxReturnType, diagnostics);
break;
}
TypeSymbol explType = null;
var explSyntax = ExplicitInterface;
if (explSyntax != null)
{
explType = parametersContext.BindType(explSyntax, diagnostics);
}
// TODOngafter 3: map dynamic->object for the signature
this.signature = new MethodSignature(Name, SyntaxArity, declaredParameterTypes, parameterRefs, explType);
}
internal MethodMemberBuilder(NamedTypeSymbol container, Binder enclosing, ConstructorDeclarationSyntax syntax, DiagnosticBag diagnostics)
: this(container, enclosing, (MemberDeclarationSyntax)syntax, diagnostics)
{
}
protected override TypeSymbol MakeReturnType(Binder binder, DelegateDeclarationSyntax syntax, DiagnosticBag diagnostics)
{
return binder.GetSpecialType(SpecialType.System_Void, diagnostics, syntax);
}
internal DelegateBinder(Binder bodyBinder, SourceNamedTypeSymbol delegateType, DelegateInvokeMethodImplementation invoke)
: base(bodyBinder)
{
this.delegateType = delegateType;
this.invoke = invoke;
}
public ExternalBinder(CompilationChain chain, Binder next)
: base(next)
{
this.chain = chain;
}
protected abstract ReadOnlyArray<ParameterSymbol> MakeParameters(Binder binder, DelegateDeclarationSyntax syntax, DiagnosticBag diagnostics);
public FixedBinder(FixedStatementSyntax syntax, MethodSymbol owner, Binder enclosing)
: base(owner, enclosing)
{
this.syntax = syntax;
}
internal DelegateInvokeMethodImplementation(
SourceNamedTypeSymbol delegateType,
DelegateDeclarationSyntax syntax,
Binder binder,
DiagnosticBag diagnostics)
: base(delegateType, syntax, MethodKind.DelegateInvoke, DeclarationModifiers.Virtual | DeclarationModifiers.Public, binder, diagnostics)
{
}
protected override TypeSymbol MakeReturnType(Binder bodyBinder, DelegateDeclarationSyntax syntax, DiagnosticBag diagnostics)
{
var delegateBinder = bodyBinder as DelegateBinder;
return delegateBinder.invoke.ReturnType;
}
protected ExecutableCodeSemanticModel(Compilation compilation, SyntaxNode rootNode, Symbol memberSymbol, Binder rootBinder)
: base(compilation, rootNode, memberSymbol)
{
this.rootBinder = rootBinder;
}
protected override ReadOnlyArray<ParameterSymbol> MakeParameters(
Binder binder,
DelegateDeclarationSyntax syntax,
DiagnosticBag diagnostics)
{
SyntaxToken extensionMethodThis;
SyntaxToken arglistToken;
var parameters = ParameterHelpers.MakeParameters(binder, this, syntax.ParameterList, true, out extensionMethodThis, out arglistToken, diagnostics);
if (arglistToken.Kind == SyntaxKind.ArgListKeyword)
{
// This is a parse-time error in the native compiler; it is a semantic analysis error in Roslyn.
// error CS1669: __arglist is not valid in this context
diagnostics.Add(ErrorCode.ERR_IllegalVarArgs, new SourceLocation(arglistToken));
}
return parameters;
}
internal MemberBuilder(SourceLocation location, Symbol accessor, Binder enclosing) // : base(location, accessor, enclosing)
{
this.location = location;
this.accessor = accessor;
this.enclosing = enclosing;
}
protected override TypeSymbol MakeReturnType(Binder bodyBinder, DelegateDeclarationSyntax syntax, DiagnosticBag diagnostics)
{
TypeSymbol returnType = bodyBinder.BindType(syntax.ReturnType, diagnostics);
if (returnType.IsRestrictedType())
{
// Method or delegate cannot return type '{0}'
diagnostics.Add(ErrorCode.ERR_MethodReturnCantBeRefAny, syntax.ReturnType.Location, returnType);
}
return returnType;
}
protected override ReadOnlyArray<ParameterSymbol> MakeParameters(
Binder binder,
DelegateDeclarationSyntax syntax,
DiagnosticBag diagnostics)
{
var delegateBinder = binder as DelegateBinder;
var parameters = ArrayBuilder<ParameterSymbol>.GetInstance();
foreach (SourceParameterSymbol p in delegateBinder.invoke.Parameters)
{
var synthesizedParam = new SourceClonedParameterSymbol(originalParam: p, newOwner: this, newOrdinal: p.Ordinal, suppressOptional: true);
parameters.Add(synthesizedParam);
}
int paramCount = delegateBinder.invoke.Parameters.Count;
parameters.Add(new SynthesizedParameterSymbol(this, binder.GetSpecialType(SpecialType.System_AsyncCallback, diagnostics, syntax), paramCount, RefKind.None, "callback"));
parameters.Add(new SynthesizedParameterSymbol(this, binder.GetSpecialType(SpecialType.System_Object, diagnostics, syntax), paramCount + 1, RefKind.None, "object"));
return parameters.ToReadOnlyAndFree();
}
internal NamespaceOrTypeBuilder(SourceLocation location, Symbol accessor, Binder enclosing) : base(location, accessor, enclosing)
{
}
