C# Syntax.BaseMethodDeclarationSyntax类代码示例

 private static bool IsCandidateForRemoval(BaseMethodDeclarationSyntax methodOrConstructor, SemanticModel semanticModel)
 {
     if (methodOrConstructor.Modifiers.Any(m => m.ValueText == "partial" || m.ValueText == "override")
         || !methodOrConstructor.ParameterList.Parameters.Any()
         || methodOrConstructor.Body == null)
         return false;
     var method = methodOrConstructor as MethodDeclarationSyntax;
     if (method != null)
     {
         if (method.ExplicitInterfaceSpecifier != null) return false;
         var methodSymbol = semanticModel.GetDeclaredSymbol(method);
         if (methodSymbol == null) return false;
         var typeSymbol = methodSymbol.ContainingType;
         if (typeSymbol.AllInterfaces.SelectMany(i => i.GetMembers())
             .Any(member => methodSymbol.Equals(typeSymbol.FindImplementationForInterfaceMember(member))))
             return false;
         if (IsEventHandlerLike(method, semanticModel)) return false;
     }
     else
     {
         var constructor = methodOrConstructor as ConstructorDeclarationSyntax;
         if (constructor != null)
         {
             if (IsSerializationConstructor(constructor, semanticModel)) return false;
         }
         else
         {
             return false;
         }
     }
     return true;
 }

        /// <summary>
        /// A position is inside a body if it is inside the block or expression
        /// body. 
        ///
        /// A position is considered to be inside a block if it is on or after
        /// the open brace and strictly before the close brace. A position is
        /// considered to be inside an expression body if it is on or after
        /// the '=>' and strictly before the semicolon.
        /// </summary>
        internal static bool IsInBody(int position, BaseMethodDeclarationSyntax method)
        {
            var exprOpt = method.GetExpressionBodySyntax();

            return IsInExpressionBody(position, exprOpt, method.SemicolonToken)
                || IsInBlock(position, method.Body);
        }

 public BaseMethodDeclarationTranslation(BaseMethodDeclarationSyntax syntax,  SyntaxTranslation parent) : base(syntax, parent)
 {
     ParameterList = syntax.ParameterList.Get<ParameterListTranslation>(this);
     Modifiers = syntax.Modifiers.Get(this);
     Body = syntax.Body.Get<BlockTranslation>(this);
     SemicolonToken = syntax.SemicolonToken.Get(this);
 }

        internal static bool IsInMethodDeclaration(int position, BaseMethodDeclarationSyntax methodDecl)
        {
            Debug.Assert(methodDecl != null);

            var body = methodDecl.Body;
            SyntaxToken lastToken = body == null ? methodDecl.SemicolonToken : body.CloseBraceToken;
            return IsBeforeToken(position, methodDecl, lastToken);
        }

 /// <summary>
 /// Constructor.
 /// </summary>
 /// <param name="context">AnalysisContext</param>
 /// <param name="method">BaseMethodDeclarationSyntax</param>
 /// <param name="parameterTypes">ITypeSymbols</param>
 private MethodSummary(AnalysisContext context, BaseMethodDeclarationSyntax method,
     IDictionary<int, ISet<ITypeSymbol>> parameterTypes)
 {
     this.Id = MethodSummary.IdCounter++;
     this.AnalysisContext = context;
     this.SemanticModel = context.Compilation.GetSemanticModel(method.SyntaxTree);
     this.Method = method;
     this.SideEffectsInfo = new MethodSideEffectsInfo(this);
     this.ResolveMethodParameterTypes(parameterTypes);
 }

 public static bool IsNoCompile(this SemanticModel model, BaseMethodDeclarationSyntax syntax)
 {
     foreach (var attrListSyntax in syntax.AttributeLists)
     {
         foreach (var attr in attrListSyntax.Attributes)
         {
             var type = model.GetTypeInfo(attr);
             if (type.Type.IsSameType(nameof(JavaScript), nameof(NoCompileAttribute)))
                 return true;
         }
     }
     return false;
 }

		public bool CanBeMadeStatic(BaseMethodDeclarationSyntax method)
		{
			if (method.Modifiers.Any(SyntaxKind.StaticKeyword)
				|| method.Body == null
				|| !method.Body.ChildNodes().Any())
			{
				return false;
			}

			var bodyNodes = method.Body.ChildNodes();
			var dataflow = _model.AnalyzeDataFlow(bodyNodes.First(), bodyNodes.Last());
			var hasThisReference = dataflow.DataFlowsIn
				.Any(x => x.Kind == SymbolKind.Parameter && x.Name == SyntaxFactory.Token(SyntaxKind.ThisKeyword).ToFullString());
			return !hasThisReference;
		}

 private static void RegisterActionForDestructor(CodeFixContext context, SyntaxNode root, BaseMethodDeclarationSyntax method)
 {
     context.RegisterCodeFix(
         CodeAction.Create(
             TitleRemoveDestructor,
             c =>
             {
                 var newRoot = root.RemoveNode(
                     method,
                     SyntaxRemoveOptions.KeepNoTrivia);
                 return Task.FromResult(context.Document.WithSyntaxRoot(newRoot));
             },
             TitleRemoveDestructor),
         context.Diagnostics);
 }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="method">BaseMethodDeclarationSyntax</param>
        /// <param name="machine">StateMachine</param>
        /// <param name="state">MachineState</param>
        /// <param name="payload">ISymbol</param>
        internal TraceInfo(BaseMethodDeclarationSyntax method, StateMachine machine,
            MachineState state, ISymbol payload)
        {
            this.ErrorTrace = new List<ErrorTraceStep>();
            this.CallTrace = new List<CallTraceStep>();

            if (method == null)
            {
                this.Method = null;
            }
            else if (method is MethodDeclarationSyntax)
            {
                this.Method = (method as MethodDeclarationSyntax).Identifier.ValueText;
            }
            else if (method is ConstructorDeclarationSyntax)
            {
                this.Method = (method as ConstructorDeclarationSyntax).Identifier.ValueText;
            }

            if (machine == null)
            {
                this.Machine = null;
            }
            else
            {
                this.Machine = machine.Name;
            }

            if (state == null)
            {
                this.State = null;
            }
            else
            {
                this.State = state.Name;
            }

            if (payload == null)
            {
                this.Payload = null;
            }
            else
            {
                this.Payload = payload.Name;
            }
        }

 /// <summary>
 /// A position is inside a body if it is inside the block or expression
 /// body. 
 ///
 /// A position is considered to be inside a block if it is on or after
 /// the open brace and strictly before the close brace. A position is
 /// considered to be inside an expression body if it is on or after
 /// the '=>' and strictly before the semicolon.
 /// </summary>
 internal static bool IsInBody(int position, BaseMethodDeclarationSyntax method)
 {
     ArrowExpressionClauseSyntax expressionBodyOpt = null;
     switch (method.Kind)
     {
         case SyntaxKind.ConversionOperatorDeclaration:
             expressionBodyOpt = ((ConversionOperatorDeclarationSyntax)method).ExpressionBody;
             break;
         case SyntaxKind.OperatorDeclaration:
             expressionBodyOpt = ((OperatorDeclarationSyntax)method).ExpressionBody;
             break;
         case SyntaxKind.MethodDeclaration:
             expressionBodyOpt = ((MethodDeclarationSyntax)method).ExpressionBody;
             break;
         default:
             break;
     }
     return IsInExpressionBody(position, expressionBodyOpt, method.SemicolonToken)
         || IsInBlock(position, method.Body);
 }

		public IEnumerable<ParameterSyntax> GetUnusedParameters(BaseMethodDeclarationSyntax method)
		{
			if (method.ParameterList.Parameters.Count == 0 || method.Body == null || !method.Body.ChildNodes().Any())
			{
				return new ParameterSyntax[0];
			}

			var bodyNodes = method.Body.ChildNodes();
			var dataflow = _model.AnalyzeDataFlow(bodyNodes.First(), bodyNodes.Last());

			var usedParameterNames = dataflow.DataFlowsIn
				.Where(x => x.Kind == SymbolKind.Parameter)
				.Select(x => x.Name)
				.AsArray();

			var unusedParameters = method.ParameterList.Parameters
				.Where(p => !usedParameterNames.Contains(p.Identifier.ValueText))
				.AsArray();
			return unusedParameters;
		}

        private static async Task<Document> ConvertToExpressionBodiedMemberAsync(
            Document document,
            BaseMethodDeclarationSyntax declaration,
            CancellationToken cancellationToken)
        {
            var body = declaration.Body;
            var returnStatement = body.Statements[0] as ReturnStatementSyntax;

            var arrowExpression = SyntaxFactory.ArrowExpressionClause(returnStatement.Expression);

            var newDeclaration = declaration;

            newDeclaration = ((dynamic)newDeclaration)
                .WithBody(null)
                .WithExpressionBody(arrowExpression)
                .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));

            newDeclaration = newDeclaration.WithAdditionalAnnotations(Formatter.Annotation);

            return await ReplaceNodeAsync(document, declaration, newDeclaration, cancellationToken);
        }

        private static void HandleBaseMethodDeclaration(
            SyntaxNodeAnalysisContext context,
            BaseMethodDeclarationSyntax baseMethodDeclarationSyntax)
        {
            var parameterListSyntax =
                baseMethodDeclarationSyntax.ParameterList;

            if (parameterListSyntax != null && !parameterListSyntax.Parameters.Any())
            {
                if (!parameterListSyntax.OpenParenToken.IsMissing &&
                    !parameterListSyntax.CloseParenToken.IsMissing)
                {
                    CheckIfLocationOfOpenAndCloseTokensAreTheSame(context, parameterListSyntax.OpenParenToken, parameterListSyntax.CloseParenToken);
                }
            }
        }

		private void AppendParameters(BaseMethodDeclarationSyntax syntax, StringBuilder builder)
		{
			builder.Append("(");
			var parameterList = syntax.ParameterList;
			if (parameterList != null)
			{
				var parameters = parameterList.Parameters;
				Func<ParameterSyntax, string> selector = parameters.Any() 
					? new Func<ParameterSyntax, string>(TypeNameSelector) 
					: x => string.Empty;
				
				var parameterNames = string.Join(", ", parameters.Select(selector).Where(x => !string.IsNullOrWhiteSpace(x)));
				builder.Append(parameterNames);
			}

			builder.Append(")");
		}

 public override IMethodSymbol GetDeclaredSymbol(BaseMethodDeclarationSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken))
 {
     // Can't define method inside member.
     return null;
 }