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);
}
