public DelegateConstructor(NamedTypeSymbol containingType, TypeSymbol objectType, TypeSymbol intPtrType)
: base(containingType)
{
_parameters = ImmutableArray.Create <ParameterSymbol>(
SynthesizedParameterSymbol.Create(this, TypeSymbolWithAnnotations.Create(objectType), 0, RefKind.None, "object"),
SynthesizedParameterSymbol.Create(this, TypeSymbolWithAnnotations.Create(intPtrType), 1, RefKind.None, "method"));
}
internal SubmissionEntryPoint(NamedTypeSymbol containingType, TypeSymbolWithAnnotations returnType, TypeSymbol submissionArrayType) :
base(containingType)
{
Debug.Assert(containingType.IsSubmissionClass);
Debug.Assert(returnType.SpecialType != SpecialType.System_Void);
_parameters = ImmutableArray.Create(SynthesizedParameterSymbol.Create(this,
TypeSymbolWithAnnotations.Create(submissionArrayType), 0, RefKind.None, "submissionArray"));
_returnType = returnType;
}
internal Constructor(
SourceMemberContainerTypeSymbol delegateType,
TypeSymbolWithAnnotations voidType,
TypeSymbolWithAnnotations objectType,
TypeSymbolWithAnnotations intPtrType,
DelegateDeclarationSyntax syntax)
: base(delegateType, voidType, syntax, MethodKind.Constructor, DeclarationModifiers.Public)
{
InitializeParameters(ImmutableArray.Create <ParameterSymbol>(
SynthesizedParameterSymbol.Create(this, objectType, 0, RefKind.None, "object"),
SynthesizedParameterSymbol.Create(this, intPtrType, 1, RefKind.None, "method")));
}
/// <summary>
/// For each parameter of a source method, construct a corresponding synthesized parameter
/// for a destination method.
/// </summary>
/// <param name="sourceMethod">Has parameters.</param>
/// <param name="destinationMethod">Needs parameters.</param>
/// <returns>Synthesized parameters to add to destination method.</returns>
internal static ImmutableArray <ParameterSymbol> DeriveParameters(MethodSymbol sourceMethod, MethodSymbol destinationMethod)
{
var builder = ArrayBuilder <ParameterSymbol> .GetInstance();
foreach (var oldParam in sourceMethod.Parameters)
{
//same properties as the old one, just change the owner
builder.Add(SynthesizedParameterSymbol.Create(destinationMethod, oldParam.Type, oldParam.Ordinal,
oldParam.RefKind, oldParam.Name, oldParam.RefCustomModifiers));
}
return(builder.ToImmutableAndFree());
}
internal SynthesizedSubmissionConstructor(NamedTypeSymbol containingType, DiagnosticBag diagnostics)
: base(containingType)
{
Debug.Assert(containingType.TypeKind == TypeKind.Submission);
Debug.Assert(diagnostics != null);
var compilation = containingType.DeclaringCompilation;
var submissionArrayType = compilation.CreateArrayTypeSymbol(compilation.GetSpecialType(SpecialType.System_Object));
var useSiteError = submissionArrayType.GetUseSiteDiagnostic();
if (useSiteError != null)
{
diagnostics.Add(useSiteError, NoLocation.Singleton);
}
_parameters = ImmutableArray.Create <ParameterSymbol>(
SynthesizedParameterSymbol.Create(this, TypeSymbolWithAnnotations.Create(submissionArrayType), 0, RefKind.None, "submissionArray"));
}
internal InvokeMethod(SynthesizedDelegateSymbol containingType, BitVector byRefParameters, TypeSymbol voidReturnTypeOpt)
{
var typeParams = containingType.TypeParameters;
_containingType = containingType;
// if we are given Void type the method returns Void, otherwise its return type is the last type parameter of the delegate:
_returnType = voidReturnTypeOpt ?? typeParams.Last();
var parameters = new ParameterSymbol[typeParams.Length - ((object)voidReturnTypeOpt != null ? 0 : 1)];
for (int i = 0; i < parameters.Length; i++)
{
// we don't need to distinguish between out and ref since this is an internal synthesized symbol:
var refKind = !byRefParameters.IsNull && byRefParameters[i] ? RefKind.Ref : RefKind.None;
parameters[i] = SynthesizedParameterSymbol.Create(this, TypeSymbolWithAnnotations.Create(typeParams[i]), i, refKind);
}
_parameters = parameters.AsImmutableOrNull();
}
internal AnonymousTypeConstructorSymbol(NamedTypeSymbol container, ImmutableArray <AnonymousTypePropertySymbol> properties)
: base(container, WellKnownMemberNames.InstanceConstructorName)
{
// Create constructor parameters
int fieldsCount = properties.Length;
if (fieldsCount > 0)
{
ParameterSymbol[] paramsArr = new ParameterSymbol[fieldsCount];
for (int index = 0; index < fieldsCount; index++)
{
PropertySymbol property = properties[index];
paramsArr[index] = SynthesizedParameterSymbol.Create(this, property.Type, index, RefKind.None, property.Name);
}
_parameters = paramsArr.AsImmutableOrNull();
}
else
{
_parameters = ImmutableArray <ParameterSymbol> .Empty;
}
}
private ImmutableArray <ParameterSymbol> MakeParameters()
{
int ordinal = 0;
var builder = ArrayBuilder <ParameterSymbol> .GetInstance();
var parameters = this.BaseMethodParameters;
foreach (var p in parameters)
{
builder.Add(SynthesizedParameterSymbol.Create(this, this.TypeMap.SubstituteType(p.OriginalDefinition.Type), ordinal++, p.RefKind, p.Name));
}
var extraSynthed = ExtraSynthesizedRefParameters;
if (!extraSynthed.IsDefaultOrEmpty)
{
foreach (var extra in extraSynthed)
{
builder.Add(SynthesizedParameterSymbol.Create(this, this.TypeMap.SubstituteType(extra), ordinal++, RefKind.Ref));
}
}
return(builder.ToImmutableAndFree());
}
internal BeginInvokeMethod(
InvokeMethod invoke,
TypeSymbolWithAnnotations iAsyncResultType,
TypeSymbolWithAnnotations objectType,
TypeSymbolWithAnnotations asyncCallbackType,
DelegateDeclarationSyntax syntax)
: base((SourceNamedTypeSymbol)invoke.ContainingType, iAsyncResultType, syntax, MethodKind.Ordinary, DeclarationModifiers.Virtual | DeclarationModifiers.Public)
{
var parameters = ArrayBuilder <ParameterSymbol> .GetInstance();
foreach (SourceParameterSymbol p in invoke.Parameters)
{
var synthesizedParam = new SourceClonedParameterSymbol(originalParam: p, newOwner: this, newOrdinal: p.Ordinal, suppressOptional: true);
parameters.Add(synthesizedParam);
}
int paramCount = invoke.ParameterCount;
parameters.Add(SynthesizedParameterSymbol.Create(this, asyncCallbackType, paramCount, RefKind.None, GetUniqueParameterName(parameters, "callback")));
parameters.Add(SynthesizedParameterSymbol.Create(this, objectType, paramCount + 1, RefKind.None, GetUniqueParameterName(parameters, "object")));
InitializeParameters(parameters.ToImmutableAndFree());
}
internal EndInvokeMethod(
InvokeMethod invoke,
TypeSymbolWithAnnotations iAsyncResultType,
DelegateDeclarationSyntax syntax)
: base((SourceNamedTypeSymbol)invoke.ContainingType, invoke.ReturnType, syntax, MethodKind.Ordinary, DeclarationModifiers.Virtual | DeclarationModifiers.Public)
{
_invoke = invoke;
var parameters = ArrayBuilder <ParameterSymbol> .GetInstance();
int ordinal = 0;
foreach (SourceParameterSymbol p in invoke.Parameters)
{
if (p.RefKind != RefKind.None)
{
var synthesizedParam = new SourceClonedParameterSymbol(originalParam: p, newOwner: this, newOrdinal: ordinal++, suppressOptional: true);
parameters.Add(synthesizedParam);
}
}
parameters.Add(SynthesizedParameterSymbol.Create(this, iAsyncResultType, ordinal++, RefKind.None, GetUniqueParameterName(parameters, "result")));
InitializeParameters(parameters.ToImmutableAndFree());
}
internal SynthesizedStringSwitchHashMethod(SourceModuleSymbol containingModule, PrivateImplementationDetails privateImplType, TypeSymbol returnType, TypeSymbol paramType)
: base(containingModule, privateImplType, returnType, PrivateImplementationDetails.SynthesizedStringHashFunctionName)
{
this.SetParameters(ImmutableArray.Create <ParameterSymbol>(SynthesizedParameterSymbol.Create(this, TypeSymbolWithAnnotations.Create(paramType), 0, RefKind.None, "s")));
}
private ImmutableArray <ParameterSymbol> MakeParameters(
CSharpCompilation compilation,
UnboundLambda unboundLambda,
ImmutableArray <TypeSymbolWithAnnotations> parameterTypes,
ImmutableArray <RefKind> parameterRefKinds,
DiagnosticBag diagnostics)
{
Debug.Assert(parameterTypes.Length == parameterRefKinds.Length);
if (!unboundLambda.HasSignature || unboundLambda.ParameterCount == 0)
{
// The parameters may be omitted in source, but they are still present on the symbol.
return(parameterTypes.SelectAsArray((type, ordinal, arg) =>
SynthesizedParameterSymbol.Create(
arg.owner,
type,
ordinal,
arg.refKinds[ordinal],
GeneratedNames.LambdaCopyParameterName(ordinal)), // Make sure nothing binds to this.
(owner: this, refKinds: parameterRefKinds)));
}
var builder = ArrayBuilder <ParameterSymbol> .GetInstance(unboundLambda.ParameterCount);
var hasExplicitlyTypedParameterList = unboundLambda.HasExplicitlyTypedParameterList;
var numDelegateParameters = parameterTypes.Length;
for (int p = 0; p < unboundLambda.ParameterCount; ++p)
{
// If there are no types given in the lambda then used the delegate type.
// If the lambda is typed then the types probably match the delegate types;
// if they do not, use the lambda types for binding. Either way, if we
// can, then we use the lambda types. (Whatever you do, do not use the names
// in the delegate parameters; they are not in scope!)
TypeSymbolWithAnnotations type;
RefKind refKind;
if (hasExplicitlyTypedParameterList)
{
type = unboundLambda.ParameterType(p);
refKind = unboundLambda.RefKind(p);
}
else if (p < numDelegateParameters)
{
type = parameterTypes[p];
refKind = parameterRefKinds[p];
}
else
{
type = TypeSymbolWithAnnotations.Create(new ExtendedErrorTypeSymbol(compilation, name: string.Empty, arity: 0, errorInfo: null));
refKind = RefKind.None;
}
var name = unboundLambda.ParameterName(p);
var location = unboundLambda.ParameterLocation(p);
var locations = location == null ? ImmutableArray <Location> .Empty : ImmutableArray.Create <Location>(location);
var parameter = new SourceSimpleParameterSymbol(this, type, p, refKind, name, locations);
builder.Add(parameter);
}
var result = builder.ToImmutableAndFree();
return(result);
}
internal AnonymousTypeEqualsMethodSymbol(NamedTypeSymbol container)
: base(container, WellKnownMemberNames.ObjectEquals)
{
_parameters = ImmutableArray.Create <ParameterSymbol>(
SynthesizedParameterSymbol.Create(this, TypeSymbolWithAnnotations.Create(this.Manager.System_Object), 0, RefKind.None, "value"));
}