C# ParameterDeclaration类代码示例

        public override void CompileTimeValidate(ParameterDeclaration parameter, Type memberType, IMessageSink messages)
        {
            base.CompileTimeValidate(parameter, memberType, messages);

            bool isString = memberType == typeof(string);

            if (!isString)
            {
                messages.Write(new Message(
                    SeverityType.Error,
                    "PatternAttribute_TypeNotSupported",
                    string.Format(CultureInfo.InvariantCulture, "The type '{0}' is not a string to perform the expression validation on.", memberType.Name),
                    GetType().FullName
                ));
            }

            if (string.IsNullOrEmpty(expression))
            {
                messages.Write(new Message(
                    SeverityType.Error,
                    "PatternAttribute_PatternNotNullOrEmpty",
                    "The expression pattern must not be null or empty.",
                    GetType().FullName
                ));
            }
        }

		void HandleVisitorParameterDeclarationVisited (ParameterDeclaration node, InspectionData data)
		{
			foreach (var rule in policy.Rules) {
				if (rule.CheckParameter (node, data))
					return;
			}
		}

        /// <summary>
        /// Initializes a new instance of the <see cref="ParameterValueToken"/> class
        /// with the specified parameter.
        /// </summary>
        /// <param name="parameter">Parameter whose value the token expands to.</param>
        /// <exception cref="ArgumentNullException"><paramref name="parameter"/> is <see langword="null"/>.</exception>
        public ParameterValueToken(ParameterDeclaration parameter)
        {
            if (parameter == null) {
                throw new ArgumentNullException("parameter");
            }

            this.parameter = parameter;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ReturnValueToken"/> class
        /// with the specified return parameter metadata.
        /// </summary>
        /// <param name="returnParameter">Return parameter metadata.</param>
        /// <exception cref="ArgumentNullException"><paramref name="returnParameter"/> is <see langword="null"/>.</exception>
        public ReturnValueToken(ParameterDeclaration returnParameter)
        {
            if (returnParameter == null) {
                throw new ArgumentNullException("returnParameter");
            }

            this.returnParameter = returnParameter;
        }

            public override object VisitParameterDeclaration(ParameterDeclaration parameterDeclaration, object data)
            {
                if (parameterDeclaration.ParameterModifier == ParameterModifier.Params)
                {
                    UnlockWith(parameterDeclaration);
                }

                return base.VisitParameterDeclaration(parameterDeclaration, data);
            }

		protected override void AssertInvocationExpression(InvocationExpression invocation, ParameterDeclaration parameter)
		{
			foreach (var member in invocation.Descendants.OfType<MemberReferenceExpression>())
			{
				if (member.MemberName == "LoadDocument")
					throw new InvalidOperationException("Reduce cannot contain LoadDocument() methods.");
			}

			base.AssertInvocationExpression(invocation, parameter);
		}

			public override void VisitParameterDeclaration (ParameterDeclaration parameterDeclaration)
			{
				base.VisitParameterDeclaration (parameterDeclaration);

				if (parameterDeclaration.Parent is ConstructorDeclaration)
					return;
				if (HidesMember (ctx, parameterDeclaration, parameterDeclaration.Name))
					AddIssue (parameterDeclaration.NameToken,
						ctx.TranslateString ("Parameter has the same name as a member and hides it"));
			}

			public override void VisitParameterDeclaration (ParameterDeclaration parameterDeclaration)
			{
				base.VisitParameterDeclaration (parameterDeclaration);

				var resolveResult = ctx.Resolve (parameterDeclaration) as LocalResolveResult;
				if (resolveResult == null)
					return;
				if (!TestOnlyAssigned (ctx, unit, resolveResult.Variable))
					return;
				AddIssue (parameterDeclaration.NameToken, 
					ctx.TranslateString ("Parameter is assigned by its value is never used"));
			}

        public static IEnumerable<ParameterDeclaration> MakeParameters(IEnumerable<ParameterDefinition> paramCol)
        {
            foreach(ParameterDefinition paramDef in paramCol) {
                ParameterDeclaration astParam = new ParameterDeclaration();
                astParam.Type = ConvertType(paramDef.ParameterType, paramDef);
                astParam.Name = paramDef.Name;

                if (!paramDef.IsIn && paramDef.IsOut) astParam.ParameterModifier = ParameterModifier.Out;
                if (paramDef.IsIn && paramDef.IsOut)  astParam.ParameterModifier = ParameterModifier.Ref;
                // TODO: params, this

                yield return astParam;
            }
        }

			public override void VisitParameterDeclaration (ParameterDeclaration parameterDeclaration)
			{
				base.VisitParameterDeclaration (parameterDeclaration);

				if (!(parameterDeclaration.Parent is MethodDeclaration))
					return;

				var resolveResult = ctx.Resolve (parameterDeclaration) as LocalResolveResult;
				if (resolveResult == null)
					return;
				if (FindUsage (ctx, unit, resolveResult.Variable, parameterDeclaration))
					return;

				AddIssue (parameterDeclaration.NameToken, ctx.TranslateString ("Parameter is never used"));
			}

            public override void VisitParameterDeclaration(ParameterDeclaration parameterDeclaration)
            {
                base.VisitParameterDeclaration(parameterDeclaration);

                var resolveResult = ctx.Resolve(parameterDeclaration) as LocalResolveResult;
                if (resolveResult == null)
                    return;

                var parameterModifier = parameterDeclaration.ParameterModifier;
                if (parameterModifier == ParameterModifier.Out || parameterModifier == ParameterModifier.Ref ||
                    !TestOnlyAssigned(ctx, parameterDeclaration.Parent, resolveResult.Variable)) {
                    return;
                }
                AddIssue(parameterDeclaration.NameToken,
                    ctx.TranslateString("Parameter is assigned but its value is never used"));
            }

        public override void CompileTimeValidate(ParameterDeclaration parameter, Type memberType, IMessageSink messages)
        {
            base.CompileTimeValidate(parameter, memberType, messages);

            if(exception != null)
            {
                if(!ValidateExceptionTypeIsException(messages))
                {
                    return;
                }
                if(!ValidateExceptionTypeCanBeInstantiated(messages))
                {
                    return;
                }
            }
        }

			public override void VisitParameterDeclaration (ParameterDeclaration parameterDeclaration)
			{
				base.VisitParameterDeclaration (parameterDeclaration);
				if (parameterDeclaration.ParameterModifier == ParameterModifier.Out ||
					parameterDeclaration.ParameterModifier == ParameterModifier.Ref)
					return;

				var resolveResult = ctx.Resolve (parameterDeclaration) as LocalResolveResult;
				BlockStatement rootStatement = null;
				if (parameterDeclaration.Parent is MethodDeclaration) {
					rootStatement = ((MethodDeclaration)parameterDeclaration.Parent).Body;
				} else if (parameterDeclaration.Parent is AnonymousMethodExpression) {
					rootStatement = ((AnonymousMethodExpression)parameterDeclaration.Parent).Body;
				} else if (parameterDeclaration.Parent is LambdaExpression) {
					rootStatement = ((LambdaExpression)parameterDeclaration.Parent).Body as BlockStatement;
				}
				CollectIssues (parameterDeclaration, rootStatement, resolveResult);
			}

        public override void CompileTimeValidate(ParameterDeclaration parameter, Type memberType, IMessageSink messages)
        {
            base.CompileTimeValidate(parameter, memberType, messages);

            bool isNullable =
                !memberType.IsValueType ||
                (memberType.IsGenericType && memberType.GetGenericTypeDefinition() == typeof(Nullable<>));

            if (!isNullable)
            {
                messages.Write(new Message(
                    SeverityType.Error,
                    "NotNullAttribute_TypeNotNullable",
                    string.Format(CultureInfo.InvariantCulture, "The type '{0}' is not nullable.", memberType.Name),
                    GetType().FullName
                ));
            }
        }

        protected override void CompileTimeValidateParameters(MethodDefDeclaration method, IMessageSink messages, ParameterDeclaration firstParameter, ParameterDeclaration secondParameter)
        {
            base.CompileTimeValidateParameters(method, messages, firstParameter, secondParameter);

            if(typeof(IComparable).IsAssignableFrom(firstParameter.ParameterType.GetSystemType(null, null)))
            {
                firstParameterIsComparable = true;
            }
            else if(typeof(IComparable).IsAssignableFrom(secondParameter.ParameterType.GetSystemType(null, null)))
            {
                firstParameterIsComparable = false;
            }
            else
            {
                messages.Write(new Message(
                    SeverityType.Error,
                    "ComparisonValidatorAttribute_ParametersCantBeCompared",
                    string.Format(CultureInfo.InvariantCulture, "None of the parameters '{0}' and '{1}' implements IComparable.", firstParameter.Name, secondParameter.Name),
                    GetType().FullName
                ));
            }
        }