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 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); }
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); }