private static SyntaxKind GetReplacementKind( ReturnStatementSyntax returnStatement, ISymbol containingSymbol, SemanticModel semanticModel, CancellationToken cancellationToken) { SyntaxToken returnKeyword = returnStatement.ReturnKeyword; ExpressionSyntax expression = returnStatement.Expression; if (semanticModel.ContainsCompilerDiagnostic(CSharpErrorCodes.CannotImplicitlyConvertType, expression.Span, cancellationToken)) { return(SyntaxKind.YieldReturnStatement); } else if (semanticModel.ContainsCompilerDiagnostic(CSharpErrorCodes.CannotReturnValueFromIterator, returnKeyword.Span, cancellationToken)) { ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(expression, cancellationToken); containingSymbol = containingSymbol ?? semanticModel.GetEnclosingSymbol(returnStatement.SpanStart, cancellationToken); if (containingSymbol?.IsKind(SymbolKind.Method) == true) { var methodSymbol = (IMethodSymbol)containingSymbol; ITypeSymbol returnType = methodSymbol.ReturnType; if (returnType.SpecialType == SpecialType.System_Collections_IEnumerable) { if (typeSymbol.IsIEnumerableOrConstructedFromIEnumerableOfT()) { return(SyntaxKind.ForEachStatement); } else { return(SyntaxKind.YieldReturnStatement); } } else if (returnType.IsNamedType()) { var namedTypeSymbol = (INamedTypeSymbol)returnType; if (namedTypeSymbol.ConstructedFrom.SpecialType == SpecialType.System_Collections_Generic_IEnumerable_T) { if (semanticModel .ClassifyConversion(expression, namedTypeSymbol.TypeArguments[0]) .IsImplicit) { return(SyntaxKind.YieldReturnStatement); } else { return(SyntaxKind.ForEachStatement); } } } } } return(SyntaxKind.None); }
void ExportStatement(ReturnStatementSyntax ss) { var node = new ULStatementReturn(); node.Parent = currentBlock; node.Arg = ExportExp(ss.Expression).GetOutputName(0); currentBlock.statements.Add(node); }
public override void VisitReturnStatement(ReturnStatementSyntax node) { m_ExistReturn = true; if (m_InLoop > 0 || m_InSwitch > 0) { m_ExistReturnInLoopOrSwitch = true; } }
public override void VisitReturnStatement(ReturnStatementSyntax node) { _writer.Write(" return "); base.VisitReturnStatement(node); _writer.WriteLine(";"); }
public override SyntaxNode VisitReturnStatement(ReturnStatementSyntax node) { if (RemoveTestTriviaAnnotation(node.GetLeadingTrivia())) { return(null); } return(base.VisitReturnStatement(node)); }
public override IEnumerable <MutantInfo> VisitReturnStatement(ReturnStatementSyntax node) { if (node.Expression != null) { return(GenerateExpressionMutants(node.Expression, lineID)); } return(new List <MutantInfo>()); }
public override void VisitReturnStatement(ReturnStatementSyntax node) { if (currentMethod != null) { currentMethod.cyclomaticComplexity++; } base.VisitReturnStatement(node); }
public override IEnumerable <IModel> VisitReturnStatement(ReturnStatementSyntax node) { var model = Create <ReturnStatement>(node); model.Expression = TransformToSingleOrNull <ExpressionModel>(node.Expression); yield return(model); }
private static void ReturnStatementExpressionCheck(ReturnStatementSyntax returnStatementExpression, SemanticModel semanticModel, Action <Diagnostic> reportDiagnostic, string filePath, CancellationToken cancellationToken) { if (returnStatementExpression.Expression != null) { var returnConversionInfo = semanticModel.GetConversion(returnStatementExpression.Expression, cancellationToken); CheckTypeConversion(returnConversionInfo, reportDiagnostic, returnStatementExpression.Expression.GetLocation(), filePath); } }
public override void VisitReturnStatement(ReturnStatementSyntax node) { base.VisitReturnStatement(node); if (node.Expression != null) { _counter++; } }
public static async Task <Document> RefactorAsync( Document document, ReturnStatementSyntax returnStatement, CancellationToken cancellationToken) { SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); SyntaxToken returnKeyword = returnStatement.ReturnKeyword; ExpressionSyntax expression = returnStatement.Expression; switch (GetReplacementKind(returnStatement, null, semanticModel, cancellationToken)) { case SyntaxKind.YieldReturnStatement: { YieldStatementSyntax yieldReturnStatement = YieldStatement( SyntaxKind.YieldReturnStatement, Token(returnKeyword.LeadingTrivia, SyntaxKind.YieldKeyword, TriviaList(Space)), returnKeyword.WithoutLeadingTrivia(), expression, returnStatement.SemicolonToken); return(await document.ReplaceNodeAsync(returnStatement, yieldReturnStatement, cancellationToken).ConfigureAwait(false)); } case SyntaxKind.ForEachStatement: { string identifier = Identifier.EnsureUniqueLocalName("item", returnStatement.SpanStart, semanticModel, cancellationToken); YieldStatementSyntax yieldReturnStatement = YieldStatement( SyntaxKind.YieldReturnStatement, Token(default(SyntaxTriviaList), SyntaxKind.YieldKeyword, TriviaList(Space)), returnKeyword.WithoutLeadingTrivia(), IdentifierName(identifier), returnStatement.SemicolonToken.WithoutTrailingTrivia()); StatementSyntax newNode = ForEachStatement( VarType(), identifier, expression, Block(yieldReturnStatement)); if (EmbeddedStatement.IsEmbeddedStatement(returnStatement)) { newNode = Block(newNode); } newNode = newNode.WithTriviaFrom(returnStatement); return(await document.ReplaceNodeAsync(returnStatement, newNode, cancellationToken).ConfigureAwait(false)); } default: { Debug.Assert(false, ""); return(document); } } }
private static void Analyze(SyntaxNodeAnalysisContext context) { PropertyDeclarationSyntax property = (PropertyDeclarationSyntax)context.Node; if (property.Type.ToString() != @"TestContext") { return; } ITypeSymbol symbol = context.SemanticModel.GetSymbolInfo(property.Type).Symbol as ITypeSymbol; if ((symbol == null) || (symbol.ToString() != @"Microsoft.VisualStudio.TestTools.UnitTesting.TestContext")) { return; } string varName = string.Empty; string propName = property.Identifier.ToString(); IEnumerable <SyntaxNode> propNodes = context.Node.DescendantNodes(); IEnumerable <ReturnStatementSyntax> returnNodes = propNodes.OfType <ReturnStatementSyntax>(); if (returnNodes.Count() > 0) { ReturnStatementSyntax returnStatement = returnNodes.First(); if (returnStatement != null) { IdentifierNameSyntax returnVar = returnStatement.Expression as IdentifierNameSyntax; if (returnVar != null) { varName = returnVar.Identifier.ToString(); } } } // find out if the property or its underlying variable is actually used foreach (IdentifierNameSyntax identifier in context.Node.Parent.DescendantNodes().OfType <IdentifierNameSyntax>()) { if ((identifier.Identifier.ToString() == propName) && (identifier.Parent != property) && !(context.SemanticModel.GetSymbolInfo(identifier).Symbol is ITypeSymbol)) { // if we find the same identifier as the propery and it's not a type or the original instance, it's used return; } if ((identifier.Identifier.ToString() == varName) && !(identifier.Parent is VariableDeclarationSyntax) && !propNodes.Contains(identifier) && !(context.SemanticModel.GetSymbolInfo(identifier).Symbol is ITypeSymbol)) { // if we find the same identifier as the variable and it's not a type, the original declaration, or part of the property, it's used return; } } // if not, report a diagnostic error Diagnostic diagnostic = Diagnostic.Create(Rule, context.Node.GetLocation()); context.ReportDiagnostic(diagnostic); return; }
public override void VisitReturnStatement(ReturnStatementSyntax node) { Debug.Assert(_returningPoint.Count > 0); if (node.Expression != null) { _graph.AddEdge(node.Expression, SourceGraphEdge.ReturnsTo, _returningPoint.Peek()); } base.VisitReturnStatement(node); }
private async Task <Document> GenerateExplicitConversion(Document document, ReturnStatementSyntax returnStatement, CancellationToken cancellationToken) { var(mappingEngine, semanticModel) = await CreateMappingEngine(document, returnStatement, cancellationToken); var returnExpressionTypeInfo = mappingEngine.GetExpressionTypeInfo(returnStatement.Expression); var mappingExpression = mappingEngine.MapExpression(returnStatement.Expression !.WithoutTrivia(), returnExpressionTypeInfo.GetAnnotatedType(), returnExpressionTypeInfo.GetAnnotatedTypeForConverted(), new MappingContext(returnStatement, semanticModel)); return(await ReplaceNode(document, returnStatement, returnStatement.WithExpression(mappingExpression), cancellationToken)); }
public override void VisitReturnStatement(ReturnStatementSyntax node) { LastStatement = new ApexReturnStatementSyntax { LeadingComments = GetLeadingAndNoApexComments(node), TrailingComments = Comments.Trailing(node), Expression = ConvertExpression(node.Expression), }; }
private void RunReturn(ReturnStatementSyntax node) { if (node.Expression != null) { Ret = RunExpression(node.Expression); } Halt = HaltType.Return; }
public override void VisitReturnStatement(ReturnStatementSyntax node) { if (node.Expression != null) { Visit(node.Expression); } _returningFromCx.Peek().UnionWith(_currentPathParents); _currentPathParents = new HashSet <int>(); }
private static BlockSyntax CreateBlockWithReturnStatement(ExpressionSyntax expression, SyntaxToken semicolon) { ReturnStatementSyntax returnStatement = ReturnStatement( ReturnKeyword().WithLeadingTrivia(expression.GetLeadingTrivia()), expression.WithoutLeadingTrivia(), semicolon); return(Block(returnStatement)); }
public override void VisitReturnStatement(ReturnStatementSyntax node) { if (entryPoint.IsMethodLevel() && node.IsParent <AnonymousFunctionExpressionSyntax>()) { return; } noscounter++; base.VisitReturnStatement(node); }
private async Task <Document> GenerateExplicitConversion(Document document, ReturnStatementSyntax returnStatement, CancellationToken cancellationToken) { var mappingEngine = await CreateMappingEngine(document, returnStatement, cancellationToken); var returnExpressionTypeInfo = mappingEngine.GetExpressionTypeInfo(returnStatement.Expression); var mappingExpression = mappingEngine.MapExpression(returnStatement.Expression, returnExpressionTypeInfo.Type, returnExpressionTypeInfo.ConvertedType); return(await ReplaceNode(document, returnStatement, returnStatement.WithExpression(mappingExpression), cancellationToken)); }
public override void VisitReturnStatement(ReturnStatementSyntax node) { if (node.Expression != null) { var patternBinder = new PatternVariableBinder(node, _enclosing); AddToMap(node, patternBinder); Visit(node.Expression, patternBinder); } }
public override SyntaxNode VisitReturnStatement(ReturnStatementSyntax node) { if (!node.DescendantNodes().Any()) { return(base.VisitReturnStatement(node)); } if (node.DescendantNodes().First() is LiteralExpressionSyntax literlaExpression) { SyntaxNode newNode = null; if (literlaExpression.IsKind(SyntaxKind.TrueLiteralExpression)) { newNode = node.ReplaceNode(literlaExpression, SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression, SyntaxFactory.Token(SyntaxKind.FalseKeyword))); } if (literlaExpression.IsKind(SyntaxKind.FalseLiteralExpression)) { newNode = node.ReplaceNode(literlaExpression, SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression, SyntaxFactory.Token(SyntaxKind.TrueKeyword))); } if (literlaExpression.IsKind(SyntaxKind.NullLiteralExpression)) { newNode = node.Parent.ReplaceNode(node.Parent, SyntaxFactory.ThrowStatement(SyntaxFactory.ObjectCreationExpression(SyntaxFactory.IdentifierName($"System.{typeof(Exception).Name}")).WithArgumentList(SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList <ArgumentSyntax>(SyntaxFactory.Argument(SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal("Mmmmutation")))))))); } if (literlaExpression.IsKind(SyntaxKind.StringLiteralExpression)) { newNode = node.ReplaceNode(literlaExpression, SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal("Mutation"))); } if (literlaExpression.IsKind(SyntaxKind.NumericLiteralExpression)) { if (double.TryParse(literlaExpression.Token.Value.ToString(), out var value)) { value = value == 0 ? 1 : 0; newNode = node.ReplaceNode(literlaExpression, SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(value))); } } if (newNode != null) { newNode = newNode.NormalizeWhitespace(); Replacers.Add(new MutationDocumentDetails(node, newNode, GetWhere(node))); } } var objectCreationExpressions = node.DescendantNodes().OfType <ObjectCreationExpressionSyntax>().ToList(); foreach (var objectCreationExpressionSyntax in objectCreationExpressions) { var newNode = node.ReplaceNode(objectCreationExpressionSyntax, SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)); Replacers.Add(new MutationDocumentDetails(node, newNode, GetWhere(node))); } return(base.VisitReturnStatement(node)); }
public override SyntaxNode VisitReturnStatement(ReturnStatementSyntax node) { // If we have only a return statement rewrite it to a return Task.CompletedTask if (node.Expression == null) { return(GetReturnTaskCompleted().WithTriviaFrom(node)); } return(base.VisitReturnStatement(node)); }
public static bool CanRefactor(ReturnStatementSyntax returnStatement, SemanticModel semanticModel, CancellationToken cancellationToken) { ExpressionSyntax expression = returnStatement.Expression; return(expression?.IsMissing == false && semanticModel .GetTypeSymbol(expression, cancellationToken)? .IsVoid() == true); }
public override void VisitReturnStatement(ReturnStatementSyntax node) { if (node.Expression is { } expression) { this.returnValues.Add(expression); } base.VisitReturnStatement(node); }
public void Render(ReturnStatementSyntax returnStatement) { Render(returnStatement.ReturnKeywordToken); if (returnStatement.EmptyExpressionNode is null) { WriteSpace(); Render(returnStatement.ExpressionNode); } }
protected override SyntaxNode Revert(BaseMethodDeclarationSyntax node) { // get expression var expression = SyntaxFactory.ArrowExpressionClause(node.Body?.Statements[0] switch { ReturnStatementSyntax returnStatement => returnStatement.Expression, ExpressionStatementSyntax expressionStatement => expressionStatement.Expression, _ => throw new InvalidOperationException($"Can't extract original expression from {node.Body}") });
public override void VisitReturnStatement(ReturnStatementSyntax node) { MethodInfo mi = m_MethodInfoStack.Peek(); mi.ExistTopLevelReturn = IsLastNodeOfMethod(node); bool isLastNode = IsLastNodeOfParent(node); if (!isLastNode) { CodeBuilder.AppendFormat("{0}do", GetIndentString()); CodeBuilder.AppendLine(); } string prestr; if (mi.SemanticInfo.MethodKind == MethodKind.Constructor) { CodeBuilder.AppendFormat("{0}return this", GetIndentString()); prestr = ", "; } else { CodeBuilder.AppendFormat("{0}return ", GetIndentString()); prestr = string.Empty; } if (null != node.Expression) { CodeBuilder.Append(prestr); IConversionExpression opd = null; var iret = m_Model.GetOperation(node) as IReturnStatement; if (null != iret) { opd = iret.ReturnedValue as IConversionExpression; } OutputExpressionSyntax(node.Expression, opd); prestr = ", "; } var names = mi.ReturnParamNames; if (names.Count > 0) { for (int i = 0; i < names.Count; ++i) { CodeBuilder.Append(prestr); CodeBuilder.Append(names[i]); prestr = ", "; } } CodeBuilder.AppendLine(";"); if (!isLastNode) { CodeBuilder.AppendFormat("{0}end;", GetIndentString()); CodeBuilder.AppendLine(); } }
private SyntaxNode FindStatementToReplace(SyntaxNode node) { return(node switch { //TODO EqualsValueClauseSyntax - Type1 v = vOfType2 AssignmentExpressionSyntax assignmentStatement => assignmentStatement, ReturnStatementSyntax returnStatement => returnStatement, YieldStatementSyntax yieldStatement => yieldStatement, _ => node.Parent == null ? null : FindStatementToReplace(node.Parent), });
/// <summary> /// Visits a return statement /// </summary> /// <param name="node">The return statement syntax</param> public override void VisitReturnStatement(ReturnStatementSyntax node) { foreach (SyntaxNode subNode in node.ChildNodes()) { _retType = FromSyntaxNode(subNode); // TODO: This will return the first return type, which could // be different than other return types. I will not care yet break; } }
public override void VisitReturnStatement(ReturnStatementSyntax node) { ((List<ReturnStatementSyntax>)Results).Add(node); base.VisitReturnStatement(node); }
public virtual void VisitReturnStatement(ReturnStatementSyntax node) { DefaultVisit(node); }
private BoundReturnStatement BindReturnStatement(ReturnStatementSyntax syntax) { BindAttributes(syntax.Attributes); return new BoundReturnStatement(syntax.Expression != null ? Bind(syntax.Expression, BindExpression) : null); }
private BoundReturnStatement BindReturnStatement(ReturnStatementSyntax syntax) { var boundExpression = BindExpression(syntax.Expression); return new BoundReturnStatement(boundExpression, syntax); }
public static ReturnStatementSyntax ReturnStatement(ExpressionSyntax expression = null) { var result = new ReturnStatementSyntax(); result.Expression = expression; return result; }
public BoundReturnStatement(BoundExpression expression, ReturnStatementSyntax syntax) : base(syntax) { Expression = expression; }
private Method TraverseReturnStatement(ReturnStatementSyntax rss) { Method retMethod = new Method(); foreach (SyntaxNode sn in rss.ChildNodes()) { if (sn is CallStatementSyntax) { retMethod.InvokedMethods.Add(TraverseInvokedMethod(sn as CallStatementSyntax)); } else if (sn is InvocationExpressionSyntax) { retMethod.InvokedMethods.Add(TraverseInvokedMethod(sn as InvocationExpressionSyntax)); } else if (sn is LocalDeclarationStatementSyntax) { Method tempMethod = TraverseVarDecls(sn as LocalDeclarationStatementSyntax); retMethod.AccessedVariables.AddRange(tempMethod.AccessedVariables); retMethod.InvokedMethods.AddRange(tempMethod.InvokedMethods); } else if (sn is AssignmentStatementSyntax) { Method tempMethod = TraverseAccessVars(sn as AssignmentStatementSyntax); retMethod.AccessedVariables.AddRange(tempMethod.AccessedVariables); retMethod.InvokedMethods.AddRange(tempMethod.InvokedMethods); } } return retMethod; }
public void VisitReturnStatement(ReturnStatementSyntax node) { if (node == null) throw new ArgumentNullException("node"); node.Validate(); WriteLeadingTrivia(node); _writer.WriteIndent(); _writer.WriteKeyword(PrinterKeyword.Return); if (node.Expression != null) { _writer.WriteSpace(); node.Expression.Accept(this); } _writer.EndStatement(); WriteTrailingTrivia(node); }
protected override SyntaxNode VisitReturnStatement(ReturnStatementSyntax node) { if (node.ExpressionOpt == null) return base.VisitReturnStatement (node); return node.Update (node.ReturnKeyword, GetReturnExpression (this.currentMethod.Identifier.ValueText, node.ExpressionOpt.ToString()), node.SemicolonToken); }
protected override void CompileReturnStatement(ReturnStatementSyntax statement) { if (CurrentMethod == Compiling.FragmentMethod) { BeginLine("__FinalOutput.Color{0}={0}", Space); CompileExpression(statement.Expression); EndLine(";"); WriteLine("return __FinalOutput;"); } else { base.CompileReturnStatement(statement); } }
public BoundReturnStatement(ReturnStatementSyntax syntax, BoundExpression expressionOpt) : base(BoundNodeKind.ReturnStatement, syntax) { ExpressionOpt = expressionOpt; }
public void Flatten(ReturnStatementSyntax node, List<FlatStatement> instructions) { if (node.Expression != null) { if (this.MethodSymbol.ReturnsVoid) { throw new NotImplementedException("returning a value from a void function"); } FlatOperand fop_return = ResolveExpression(node.Expression, null, instructions); instructions.Add(FlatStatement.REREFERENCE(FlatOperand.InputRef(0, FlatValue.Null()),fop_return)); } instructions.Add(FlatStatement.RETURN()); }
public void SetReturnStatement(SyntaxNode statement) { this.statement = (ReturnStatementSyntax) statement; }
public virtual void Visit(ReturnStatementSyntax returnStatementSyntax) { Visit(returnStatementSyntax.Expression); }
public override SyntaxNode VisitReturnStatement(ReturnStatementSyntax node) { var based = base.VisitReturnStatement (node); based = based.WithTrailingTrivia (based.GetTrailingTrivia().Prepend (GetIdComment())); return based; }
protected abstract void CompileReturnStatement(ReturnStatementSyntax statement);