public override SyntaxNode VisitParenthesizedLambdaExpression(ParenthesizedLambdaExpressionSyntax node) { node = (ParenthesizedLambdaExpressionSyntax)base.VisitParenthesizedLambdaExpression(node); if (transformKind == TransformKind.LambdaToAnonMethod) { // If any of the lambda parameters do not have type explicitly specified then we don't do any transforms. foreach (var parameter in node.ParameterList.Parameters) { if (parameter.Type == null) { return node; } } // If the body of the lambda is not a block syntax we don't do any transforms. if (node.Body.Kind() != SyntaxKind.Block) { return node; } return SyntaxFactory.AnonymousMethodExpression( default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.DelegateKeyword), node.ParameterList, (BlockSyntax)node.Body); } return node; }
public override SyntaxNode VisitParenthesizedLambdaExpression(ParenthesizedLambdaExpressionSyntax node) { return SimplifyNode( node, newNode: base.VisitParenthesizedLambdaExpression(node), parentNode: node.Parent, simplifier: SimplifyParenthesizedLambdaExpression); }
public override SyntaxNode VisitParenthesizedLambdaExpression(ParenthesizedLambdaExpressionSyntax node) { if (_predicate(node) && CanSimplify(_document, node, _cancellationToken)) { var invocation = TryGetInvocationExpression(node.Body); if (invocation != null) { return SimplifyInvocation(invocation); } } return base.VisitParenthesizedLambdaExpression(node); }
public override SyntaxNode VisitParenthesizedLambdaExpression(ParenthesizedLambdaExpressionSyntax node) { this.lambdaStack.Push(node); try { return base.VisitParenthesizedLambdaExpression(node); } finally { this.lambdaStack.Pop(); } }
internal static bool IsInAnonymousFunctionOrQuery(int position, SyntaxNode lambdaExpressionOrQueryNode) { Debug.Assert(lambdaExpressionOrQueryNode.IsAnonymousFunction() || lambdaExpressionOrQueryNode.IsQuery()); SyntaxToken firstIncluded; CSharpSyntaxNode body; switch (lambdaExpressionOrQueryNode.Kind()) { case SyntaxKind.SimpleLambdaExpression: SimpleLambdaExpressionSyntax simple = (SimpleLambdaExpressionSyntax)lambdaExpressionOrQueryNode; firstIncluded = simple.Parameter.Identifier; body = simple.Body; break; case SyntaxKind.ParenthesizedLambdaExpression: ParenthesizedLambdaExpressionSyntax parenthesized = (ParenthesizedLambdaExpressionSyntax)lambdaExpressionOrQueryNode; firstIncluded = parenthesized.ParameterList.OpenParenToken; body = parenthesized.Body; break; case SyntaxKind.AnonymousMethodExpression: AnonymousMethodExpressionSyntax anon = (AnonymousMethodExpressionSyntax)lambdaExpressionOrQueryNode; firstIncluded = anon.DelegateKeyword; body = anon.Block; break; default: // OK, so we have some kind of query clause. They all start with a keyword token, so we'll skip that. firstIncluded = lambdaExpressionOrQueryNode.GetFirstToken().GetNextToken(); return(IsBetweenTokens(position, firstIncluded, lambdaExpressionOrQueryNode.GetLastToken().GetNextToken())); } var bodyStatement = body as StatementSyntax; var firstExcluded = bodyStatement != null? GetFirstExcludedToken(bodyStatement) : (SyntaxToken)SyntaxNavigator.Instance.GetNextToken(body, predicate: null, stepInto: null); return(IsBetweenTokens(position, firstIncluded, firstExcluded)); }
public override void VisitParenthesizedLambdaExpression(ParenthesizedLambdaExpressionSyntax node) { VisitLambdaExpression(node); }
public override void VisitParenthesizedLambdaExpression(ParenthesizedLambdaExpressionSyntax node) { for (int i = 0; i < node.ParameterList.Parameters.Count; ++i) { var name = node.ParameterList.Parameters[i].Identifier.ValueText; parameters[name] = Expression.Parameter(paramTypes[i], name); } base.VisitParenthesizedLambdaExpression(node); expression = Expression.Lambda(expression, parameters.Values); }
public override void VisitParenthesizedLambdaExpression(ParenthesizedLambdaExpressionSyntax node) { // ignore lambdas }
public override void VisitParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax node) { base.VisitParenthesizedLambdaExpression(node); VisitBody("Lambda expression", node.ArrowToken, node.Body as StatementSyntax, null); }
public override bool VisitParenthesizedLambdaExpression(ParenthesizedLambdaExpressionSyntax node) { return false; }
private IEnumerable<ITypeSymbol> InferTypeInParenthesizedLambdaExpression(ParenthesizedLambdaExpressionSyntax lambdaExpression, SyntaxToken? previousToken = null) { // If we have a position, it has to be after the lambda arrow. if (previousToken.HasValue && previousToken.Value != lambdaExpression.ArrowToken) { return SpecializedCollections.EmptyEnumerable<ITypeSymbol>(); } return InferTypeInLambdaExpression(lambdaExpression); }
private SyntaxNode FixParenthesizedLambda(ParenthesizedLambdaExpressionSyntax lambda) { return lambda.WithoutLeadingTrivia() .WithAsyncKeyword(s_asyncToken.WithPrependedLeadingTrivia(lambda.GetLeadingTrivia())); }
public static void Go(OutputWriter writer, ParenthesizedLambdaExpressionSyntax expression) { Go(writer, expression.ParameterList.Parameters, expression.Body, TypeProcessor.GetTypeInfo(expression)); }
private ITypeSymbol InferTypeForFirstParameterOfParenthesizedLambda( ParenthesizedLambdaExpressionSyntax lambdaExpression) { return lambdaExpression.ParameterList.Parameters.Count == 0 ? null : InferTypeForFirstParameterOfLambda( lambdaExpression, lambdaExpression.ParameterList.Parameters[0]); }
/// <summary> /// /// </summary> /// <param name="node"></param> public override sealed void VisitParenthesizedLambdaExpression(ParenthesizedLambdaExpressionSyntax node) { this.OnNodeVisited(node); if (!this.traverseRootOnly) base.VisitParenthesizedLambdaExpression(node); }
private SyntaxNode FixParenthesizedLambda(ParenthesizedLambdaExpressionSyntax lambda) { return lambda.WithAsyncKeyword(default(SyntaxToken)).WithPrependedLeadingTrivia(lambda.AsyncKeyword.LeadingTrivia); }
public override void VisitParenthesizedLambdaExpression(ParenthesizedLambdaExpressionSyntax node) { var saveCurrentScope = currentScope; var parametersScope = new DeclarationScope(saveCurrentScope); currentScope = parametersScope; Visit(node.ParameterList); Debug.Assert(currentScope == parametersScope); currentScope = new DeclarationScope(parametersScope); Visit(node.Body); Debug.Assert(currentScope.Parent == parametersScope); Debug.Assert(currentScope.Parent.Parent == saveCurrentScope); currentScope = saveCurrentScope; }
public static string ParenthesizedLambdaExpression(ParenthesizedLambdaExpressionSyntax lambda) { var output = "{ "; output += SyntaxNode(lambda.ParameterList) + " in" + NewLine; return output + Block((BlockSyntax)lambda.Body, false) + NewLine + "}"; }
public override SyntaxNode VisitParenthesizedLambdaExpression(ParenthesizedLambdaExpressionSyntax node) { var newNode = base.VisitParenthesizedLambdaExpression(node); if (newNode is ParenthesizedLambdaExpressionSyntax) { var parenthesizedLambda = (ParenthesizedLambdaExpressionSyntax)newNode; // First, try to add a cast to the lambda. ExpressionSyntax newLambdaExpressionBodyWithCast; if (TryGetLambdaExpressionBodyWithCast(node, parenthesizedLambda, out newLambdaExpressionBodyWithCast)) { parenthesizedLambda = parenthesizedLambda.WithBody(newLambdaExpressionBodyWithCast); } // Next, try to add a types to the lambda parameters if (_expandParameter && parenthesizedLambda.ParameterList != null) { var parameterList = parenthesizedLambda.ParameterList; var parameters = parameterList.Parameters.ToArray(); if (parameters.Length > 0 && parameters.Any(p => p.Type == null)) { var parameterSymbols = node.ParameterList.Parameters .Select(p => _semanticModel.GetDeclaredSymbol(p, _cancellationToken)) .ToArray(); if (parameterSymbols.All(p => p.Type?.ContainsAnonymousType() == false)) { var newParameters = parameterList.Parameters; for (int i = 0; i < parameterSymbols.Length; i++) { var typeSyntax = parameterSymbols[i].Type.GenerateTypeSyntax().WithTrailingTrivia(s_oneWhitespaceSeparator); var newParameter = parameters[i].WithType(typeSyntax).WithAdditionalAnnotations(Simplifier.Annotation); var currentParameter = newParameters[i]; newParameters = newParameters.Replace(currentParameter, newParameter); } var newParameterList = parameterList.WithParameters(newParameters); var newParenthesizedLambda = parenthesizedLambda.WithParameterList(newParameterList); return SimplificationHelpers.CopyAnnotations(from: parenthesizedLambda, to: newParenthesizedLambda); } } } return parenthesizedLambda; } return newNode; }
public override void VisitParenthesizedLambdaExpression(ParenthesizedLambdaExpressionSyntax node) { var tokens = node.ParameterList.Parameters.Select(p => p.Identifier); tracker.AddIdentifiers(tokens); Visit(node.Body); tracker.RemoveIdentifiers(tokens); }
public override SyntaxNode VisitParenthesizedLambdaExpression(ParenthesizedLambdaExpressionSyntax node) { var info = _semanticModel.GetTypeInfo(node); _output.Write(node, "function ({0}) ", this.MakeParametersList(node.ParameterList)); _output.TrivialWriteLine('{'); _output.IncreaseIndent(); if (node.Body.Kind() != SyntaxKind.Block) { if (info.DelegateReturnValue()) _output.TrivialWrite("return "); } this.Visit(node.Body); if (node.Body.Kind() != SyntaxKind.Block) { _output.TrivialWriteLine(';'); } _output.DecreaseIndent(); _output.TrivialWrite('}'); return node; }
/// <summary> /// /// </summary> /// <param name="node"></param> public override sealed void VisitParenthesizedLambdaExpression(ParenthesizedLambdaExpressionSyntax node) { this.OnNodeVisited(node, this.type.IsInstanceOfType(node)); base.VisitParenthesizedLambdaExpression(node); }
public override void VisitParenthesizedLambdaExpression(ParenthesizedLambdaExpressionSyntax node) { CSharpSyntaxNode body = node.Body; if (body.Kind() == SyntaxKind.Block) { VisitBlock((BlockSyntax)body); } }
private static SyntaxNode ConvertParenthesizedLambdaToAsync(ParenthesizedLambdaExpressionSyntax parenthesizedLambda) { return SyntaxFactory.ParenthesizedLambdaExpression( SyntaxFactory.Token(SyntaxKind.AsyncKeyword), parenthesizedLambda.ParameterList, parenthesizedLambda.ArrowToken, parenthesizedLambda.RefKeyword, parenthesizedLambda.Body) .WithTriviaFrom(parenthesizedLambda) .WithAdditionalAnnotations(Formatter.Annotation); }
public ParenthesizedLambdaExpressionTranslation(ParenthesizedLambdaExpressionSyntax syntax, SyntaxTranslation parent) : base(syntax, parent) { Body = syntax.Body.Get<CSharpSyntaxTranslation>(this); ParameterList = syntax.ParameterList.Get<ParameterListTranslation>(this); }
public override SyntaxNode VisitParenthesizedLambdaExpression(ParenthesizedLambdaExpressionSyntax node) { return base.VisitParenthesizedLambdaExpression(node); }