private SubstitutedParameterSymbol(Symbol containingSymbol, TypeMap map, ParameterSymbol originalParameter) :
     base(originalParameter)
 {
     Debug.Assert(originalParameter.IsDefinition);
     _containingSymbol = containingSymbol;
     _mapOrType = map;
 }

 internal DisplayClassInstanceFromParameter(ParameterSymbol parameter)
 {
     Debug.Assert((object)parameter != null);
     Debug.Assert(parameter.Name.EndsWith("this", StringComparison.Ordinal) ||
         GeneratedNames.GetKind(parameter.Name) == GeneratedNameKind.TransparentIdentifier);
     this.Parameter = parameter;
 }

 internal static BoundNode Rewrite(
     ParameterSymbol targetMethodThisParameter,
     Conversions conversions,
     ImmutableDictionary<string, DisplayClassVariable> displayClassVariables,
     BoundNode node,
     DiagnosticBag diagnostics)
 {
     var rewriter = new CapturedVariableRewriter(targetMethodThisParameter, conversions, displayClassVariables, diagnostics);
     return rewriter.Visit(node);
 }

 private CapturedVariableRewriter(
     ParameterSymbol targetMethodThisParameter,
     Conversions conversions,
     ImmutableDictionary<string, DisplayClassVariable> displayClassVariables,
     DiagnosticBag diagnostics)
 {
     _targetMethodThisParameter = targetMethodThisParameter;
     _conversions = conversions;
     _displayClassVariables = displayClassVariables;
     _diagnostics = diagnostics;
 }

        internal override bool TryGetThisParameter(out ParameterSymbol thisParameter)
        {
            Debug.Assert(!IsStatic);

            if ((object)_lazyThisParameter == null)
            {
                Interlocked.CompareExchange(ref _lazyThisParameter, new ThisParameterSymbol(this), null);
            }

            thisParameter = _lazyThisParameter;
            return true;
        }

        internal override bool TryGetThisParameter(out ParameterSymbol thisParameter)
        {
            if (IsStatic)
            {
                thisParameter = null;
                return true;
            }

            if ((object)lazyThisParameter == null)
            {
                Interlocked.CompareExchange(ref lazyThisParameter, new ThisParameterSymbol(this), null);
            }

            thisParameter = lazyThisParameter;
            return true;
        }

 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] = new SynthesizedParameterSymbol(this, property.Type, index, RefKind.None, property.Name);
         }
         _parameters = paramsArr.AsImmutableOrNull();
     }
     else
     {
         _parameters = ImmutableArray<ParameterSymbol>.Empty;
     }
 }

        internal static void VerifyParamArrayAttribute(ParameterSymbol parameter, SourceModuleSymbol module, bool expected = true, OutputKind outputKind = OutputKind.ConsoleApplication)
        {
            Assert.Equal(expected, parameter.IsParams);

            var emitModule = new PEAssemblyBuilder(module.ContainingSourceAssembly, null, outputKind, GetDefaultModulePropertiesForSerialization(), SpecializedCollections.EmptyEnumerable<ResourceDescription>());
            var paramArrayAttributeCtor = (MethodSymbol)emitModule.Compilation.GetWellKnownTypeMember(WellKnownMember.System_ParamArrayAttribute__ctor);
            bool found = false;

            var context = new EmitContext(emitModule, null, new DiagnosticBag());

            foreach (Microsoft.Cci.ICustomAttribute attr in parameter.GetSynthesizedAttributes())
            {
                if (paramArrayAttributeCtor == (MethodSymbol)attr.Constructor(context))
                {
                    Assert.False(found, "Multiple ParamArrayAttribute");
                    found = true;
                }
            }

            Assert.Equal(expected, found);
            context.Diagnostics.Verify();
        }

        private ImmutableArray<ParameterSymbol> RetargetParameters()
        {
            var list = this.underlyingMethod.Parameters;
            int count = list.Length;

            if (count == 0)
            {
                return ImmutableArray<ParameterSymbol>.Empty;
            }
            else
            {
                ParameterSymbol[] parameters = new ParameterSymbol[count];

                for (int i = 0; i < count; i++)
                {
                    parameters[i] = new RetargetingMethodParameterSymbol(this, list[i]);
                }

                return parameters.AsImmutableOrNull();
            }
        }

 protected override void EnterParameter(ParameterSymbol parameter)
 {
     // parameters are NOT intitially assigned here - if that is a problem, then
     // the parameters must be captured.
     GetOrCreateSlot(parameter);
 }

        private static bool CanBeOptional(ParameterSymbol parameter, bool isMethodGroupConversion)
        {
            // NOTE: Section 6.6 will be slightly updated:
            //
            //   - The candidate methods considered are only those methods that are applicable in their
            //     normal form (§7.5.3.1), and do not omit any optional parameters. Thus, candidate methods
            //     are ignored if they are applicable only in their expanded form, or if one or more of their
            //     optional parameters do not have a corresponding parameter in the targeted delegate type.
            //   
            // Therefore, no parameters are optional when performing method group conversion.  Alternatively,
            // we could eliminate methods based on the number of arguments, but then we wouldn't be able to
            // fall back on them if no other candidates were available.

            var refKind = parameter.RefKind;
            return !isMethodGroupConversion && parameter.IsOptional &&
                (refKind == RefKind.None ||
                 (refKind == RefKind.Ref && parameter.ContainingSymbol.ContainingType.IsComImport));
        }

 private static ParameterSymbol CopyParameter(ParameterSymbol parameter, MethodSymbol owner)
 {
     return new SynthesizedParameterSymbol(
         owner,
         parameter.Type,
         parameter.Ordinal,
         parameter.RefKind,
         GeneratedNames.LambdaCopyParameterName(parameter)); // Make sure nothing binds to this.
 }

 protected override void ReportUnassignedOutParameter(ParameterSymbol parameter, CSharpSyntaxNode node, Location location)
 {
     if (!dataFlowsOut.Contains(parameter) && (node == null || node is ReturnStatementSyntax))
     {
         dataFlowsOut.Add(parameter);
     }
     base.ReportUnassignedOutParameter(parameter, node, location);
 }

        public ParameterTypeInformation(ParameterSymbol underlyingParameter)
        {
            Debug.Assert((object)underlyingParameter != null);

            this.UnderlyingParameter = underlyingParameter;
        }

        private static TypedConstant GetParamArrayArgument(ParameterSymbol parameter, ImmutableArray<TypedConstant> constructorArgsArray, int argumentsCount, int argsConsumedCount, Conversions conversions)
        {
            Debug.Assert(argsConsumedCount <= argumentsCount);

            int paramArrayArgCount = argumentsCount - argsConsumedCount;
            if (paramArrayArgCount == 0)
            {
                return new TypedConstant(parameter.Type, ImmutableArray<TypedConstant>.Empty);
            }

            // If there's exactly one argument and it's an array of an appropriate type, then just return it.
            if (paramArrayArgCount == 1 && constructorArgsArray[argsConsumedCount].Kind == TypedConstantKind.Array)
            {
                TypeSymbol argumentType = (TypeSymbol)constructorArgsArray[argsConsumedCount].Type;

                // Easy out (i.e. don't both classifying conversion).
                if (argumentType == parameter.Type)
                {
                    return constructorArgsArray[argsConsumedCount];
                }

                HashSet<DiagnosticInfo> useSiteDiagnostics = null; // ignoring, since already bound argument and parameter
                Conversion conversion = conversions.ClassifyConversion(argumentType, parameter.Type, ref useSiteDiagnostics, builtinOnly: true);

                // NOTE: Won't always succeed, even though we've performed overload resolution.
                // For example, passing int[] to params object[] actually treats the int[] as an element of the object[].
                if (conversion.IsValid && conversion.Kind == ConversionKind.ImplicitReference)
                {
                    return constructorArgsArray[argsConsumedCount];
                }
            }

            Debug.Assert(!constructorArgsArray.IsDefault);
            Debug.Assert(argsConsumedCount <= constructorArgsArray.Length);

            var values = new TypedConstant[paramArrayArgCount];

            for (int i = 0; i < paramArrayArgCount; i++)
            {
                values[i] = constructorArgsArray[argsConsumedCount++];
            }

            return new TypedConstant(parameter.Type, values.AsImmutableOrNull());
        }

 public BoundParameter Parameter(ParameterSymbol p)
 {
     return new BoundParameter(Syntax, p, p.Type) { WasCompilerGenerated = true };
 }

 private static ParameterSymbol CopyParameter(ParameterSymbol parameter, MethodSymbol owner)
 {
     return new SynthesizedParameterSymbol(
             owner,
         parameter.Type,
         parameter.Ordinal,
         parameter.RefKind,
             string.Empty); // Make sure nothing binds to this.
 }

 /// <summary>
 /// Creates a SemanticModel for a parameter default value.
 /// </summary>
 internal static InitializerSemanticModel Create(CSharpCompilation compilation, ParameterSyntax syntax, ParameterSymbol parameterSymbol, Binder rootBinder)
 {
     return new InitializerSemanticModel(compilation, syntax, parameterSymbol, rootBinder);
 }

 internal static string LambdaCopyParameterName(ParameterSymbol sourceParameter)
 {
     return "<" + sourceParameter.Name + ">";
 }

        internal sealed override bool TryGetThisParameter(out ParameterSymbol thisParameter)
        {
            // Required in EE scenarios.  Specifically, the EE binds in the context of a 
            // substituted method, whereas the core compiler always binds within the
            // context of an original definition.  
            // There should never be any reason to call this in normal compilation
            // scenarios, but the behavior should be sensible if it does occur.
            ParameterSymbol originalThisParameter;
            if (!originalDefinition.TryGetThisParameter(out originalThisParameter))
            {
                thisParameter = null;
                return false;
            }

            thisParameter = (object)originalThisParameter != null
                ? new ThisParameterSymbol(this)
                : null;
            return true;
        }