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; }
public SynthesizedSealedPropertyAccessor(PropertySymbol property, MethodSymbol overriddenAccessor) { Debug.Assert((object)property != null); Debug.Assert(property.IsSealed); Debug.Assert((object)overriddenAccessor != null); _property = property; _overriddenAccessor = overriddenAccessor; _parameters = SynthesizedParameterSymbol.DeriveParameters(overriddenAccessor, this); }
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 AsyncForwardEntryPoint(CSharpCompilation compilation, NamedTypeSymbol containingType, MethodSymbol userMain) : base(containingType) { // There should be no way for a userMain to be passed in unless it already passed the // parameter checks for determining entrypoint validity. Debug.Assert(userMain.ParameterCount == 0 || userMain.ParameterCount == 1); _userMainReturnTypeSyntax = userMain.ExtractReturnTypeSyntax(); var binder = compilation.GetBinder(_userMainReturnTypeSyntax); _parameters = SynthesizedParameterSymbol.DeriveParameters(userMain, this); var arguments = Parameters.SelectAsArray((p, s) => (BoundExpression) new BoundParameter(s, p, p.Type.TypeSymbol), _userMainReturnTypeSyntax); // Main(args) or Main() BoundCall userMainInvocation = new BoundCall( syntax: _userMainReturnTypeSyntax, receiverOpt: null, method: userMain, arguments: arguments, argumentNamesOpt: default(ImmutableArray <string>), argumentRefKindsOpt: default(ImmutableArray <RefKind>), isDelegateCall: false, expanded: false, invokedAsExtensionMethod: false, argsToParamsOpt: default(ImmutableArray <int>), resultKind: LookupResultKind.Viable, binderOpt: binder, type: userMain.ReturnType.TypeSymbol) { WasCompilerGenerated = true }; // The diagnostics that would be produced here will already have been captured and returned. var droppedBag = DiagnosticBag.GetInstance(); var success = binder.GetAwaitableExpressionInfo(userMainInvocation, out _, out _, out _, out _getAwaiterGetResultCall, _userMainReturnTypeSyntax, droppedBag); droppedBag.Free(); Debug.Assert( ReturnType.SpecialType == SpecialType.System_Void || ReturnType.SpecialType == SpecialType.System_Int32); }
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()); }
public SynthesizedImplementationMethod( MethodSymbol interfaceMethod, NamedTypeSymbol implementingType, string name = null, bool generateDebugInfo = true, PropertySymbol associatedProperty = null) { //it does not make sense to add methods to substituted types Debug.Assert(implementingType.IsDefinition); _name = name ?? ExplicitInterfaceHelpers.GetMemberName(interfaceMethod.Name, interfaceMethod.ContainingType, aliasQualifierOpt: null); _implementingType = implementingType; _generateDebugInfo = generateDebugInfo; _associatedProperty = associatedProperty; _explicitInterfaceImplementations = ImmutableArray.Create <MethodSymbol>(interfaceMethod); // alpha-rename to get the implementation's type parameters var typeMap = interfaceMethod.ContainingType.TypeSubstitution ?? TypeMap.Empty; typeMap.WithAlphaRename(interfaceMethod, this, out _typeParameters); _interfaceMethod = interfaceMethod.ConstructIfGeneric(TypeArguments); _parameters = SynthesizedParameterSymbol.DeriveParameters(_interfaceMethod, this); }
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")); }