public LambdaBlock <MessageType> CreateLambdaBlock <MessageType>(Func <MessageType, bool> LambdaFunction, string name)
{
var block = new LambdaBlock <MessageType>(EventProcessor, LambdaFunction);
SetDebugName(block, name);
return(block);
}
private void Init(string name)
{
adapter = new BaseInputAdapter();
LambdaBlock <object> b = Express2.BlockFactory.CreateLambdaBlock <object>(x => true, name);
ExprTree.CreateComponent(this, b);
adapter.Attach(this);
}
public ICEPExpression <InputType> Perform(Action <InputType> action)
{
LambdaBlock <InputType> block = blockFactory.CreateLambdaBlock <InputType>(
input =>
{
action(input);
return(true);
}, "Perform");
return(CreateChildExpr <InputType>(this, block, "Perform."));
}
private static void Analyze <TNode>(
SyntaxNodeAnalysisContext context,
SyntaxNodeOrToken openNodeOrToken,
SeparatedSyntaxList <TNode> nodes) where TNode : SyntaxNode
{
TNode first = nodes.FirstOrDefault();
if (first == null)
{
return;
}
TextSpan span = nodes.GetSpan(includeExteriorTrivia: false);
if (span.IsSingleLine(first.SyntaxTree))
{
SyntaxTriviaList trailing = openNodeOrToken.GetTrailingTrivia();
if (!IsOptionalWhitespaceThenOptionalSingleLineCommentThenEndOfLineTrivia(trailing))
{
return;
}
int indentationLength = GetIncreasedIndentationLength(openNodeOrToken.Parent);
if (indentationLength == 0)
{
return;
}
if (ShouldFixIndentation(first.GetLeadingTrivia(), indentationLength))
{
ReportDiagnostic();
}
}
else
{
TextLineCollection lines = null;
IndentationAnalysis indentationAnalysis = IndentationAnalysis.Create(openNodeOrToken.Parent);
int indentationLength = indentationAnalysis.IncreasedIndentationLength;
if (indentationLength == 0)
{
return;
}
for (int i = nodes.Count - 1; i >= 0; i--)
{
SyntaxTriviaList trailing = (i == 0)
? openNodeOrToken.GetTrailingTrivia()
: nodes.GetSeparator(i - 1).TrailingTrivia;
if (IsOptionalWhitespaceThenOptionalSingleLineCommentThenEndOfLineTrivia(trailing))
{
if (ShouldFixIndentation(nodes[i].GetLeadingTrivia(), indentationLength))
{
ReportDiagnostic();
break;
}
}
else
{
if (nodes.Count > 1 &&
ShouldWrapAndIndent(context.Node, i))
{
ReportDiagnostic();
break;
}
if (nodes.Count == 1 &&
first.IsKind(SyntaxKind.Argument))
{
var argument = (ArgumentSyntax)(SyntaxNode)first;
LambdaBlock lambdaBlock = GetLambdaBlock(argument, lines ??= first.SyntaxTree.GetText().Lines);
if (lambdaBlock.Block != null)
{
SyntaxToken token = lambdaBlock.Token;
SyntaxTriviaList leading = token.LeadingTrivia;
if (leading.Any())
{
SyntaxTrivia trivia = leading.Last();
if (trivia.IsWhitespaceTrivia() &&
trivia.SpanStart == lambdaBlock.LineStartIndex &&
trivia.Span.Length != indentationAnalysis.IndentationLength)
{
ReportDiagnostic();
break;
}
}
else if (lambdaBlock.LineStartIndex == token.SpanStart)
{
ReportDiagnostic();
break;
}
return;
}
}
if (lines == null)
{
lines = first.SyntaxTree.GetText().Lines;
}
int lineIndex = lines.IndexOf(span.Start);
if (lineIndex < lines.Count - 1)
{
int lineStartIndex = lines[lineIndex + 1].Start;
if (first.Span.Contains(lineStartIndex))
{
SyntaxToken token = first.FindToken(lineStartIndex);
if (!token.IsKind(SyntaxKind.None))
{
SyntaxTriviaList leading = token.LeadingTrivia;
if (leading.Any())
{
if (leading.FullSpan.Contains(lineStartIndex))
{
SyntaxTrivia trivia = leading.Last();
if (trivia.IsWhitespaceTrivia() &&
trivia.SpanStart == lineStartIndex &&
trivia.Span.Length != indentationLength)
{
ReportDiagnostic();
break;
}
}
}
else if (lineStartIndex == token.SpanStart)
{
ReportDiagnostic();
break;
}
}
}
}
}
}
}
void ReportDiagnostic()
{
DiagnosticHelpers.ReportDiagnostic(
context,
DiagnosticDescriptors.FixFormattingOfList,
Location.Create(first.SyntaxTree, nodes.Span),
GetTitle());
}
internal static List <TextChange> GetFixListChanges <TNode>(
SyntaxNode containingNode,
SyntaxNodeOrToken openNodeOrToken,
IReadOnlyList <TNode> nodes,
ListFixMode fixMode = ListFixMode.Fix,
CancellationToken cancellationToken = default) where TNode : SyntaxNode
{
IndentationAnalysis indentationAnalysis = AnalyzeIndentation(containingNode, cancellationToken);
string increasedIndentation = indentationAnalysis.GetIncreasedIndentation();
bool isSingleLine;
SeparatedSyntaxList <TNode> separatedList = default;
if (nodes is SyntaxList <TNode> list)
{
isSingleLine = list.IsSingleLine(includeExteriorTrivia: false, cancellationToken: cancellationToken);
}
else
{
separatedList = (SeparatedSyntaxList <TNode>)nodes;
isSingleLine = separatedList.IsSingleLine(
includeExteriorTrivia: false,
cancellationToken: cancellationToken);
}
if (isSingleLine &&
fixMode == ListFixMode.Fix)
{
TNode node = nodes[0];
SyntaxTriviaList leading = node.GetLeadingTrivia();
TextSpan span = (leading.Any() && leading.Last().IsWhitespaceTrivia())
? leading.Last().Span
: new TextSpan(node.SpanStart, 0);
return(new List <TextChange>()
{
new TextChange(span, increasedIndentation)
});
}
var textChanges = new List <TextChange>();
TextLineCollection lines = null;
string endOfLine = DetermineEndOfLine(containingNode).ToString();
for (int i = 0; i < nodes.Count; i++)
{
SyntaxToken token;
if (i == 0)
{
token = (openNodeOrToken.IsNode)
? openNodeOrToken.AsNode().GetLastToken()
: openNodeOrToken.AsToken();
}
else
{
token = (list == default)
? separatedList.GetSeparator(i - 1)
: list[i - 1].GetLastToken();
}
SyntaxTriviaList trailing = token.TrailingTrivia;
TNode node = nodes[i];
var indentationAdded = false;
if (IsOptionalWhitespaceThenOptionalSingleLineCommentThenEndOfLineTrivia(trailing))
{
SyntaxTrivia last = node.GetLeadingTrivia().LastOrDefault();
if (last.IsWhitespaceTrivia())
{
if (last.Span.Length == increasedIndentation.Length)
{
continue;
}
textChanges.Add(last.Span, increasedIndentation);
}
else
{
textChanges.Add(new TextSpan(node.SpanStart, 0), increasedIndentation);
}
indentationAdded = true;
}
else
{
if (nodes.Count == 1 &&
node is ArgumentSyntax argument)
{
LambdaBlock lambdaBlock = GetLambdaBlock(argument, lines ??= argument.SyntaxTree.GetText().Lines);
if (lambdaBlock.Block != null)
{
increasedIndentation = indentationAnalysis.Indentation.ToString();
}
}
if ((nodes.Count > 1 || fixMode == ListFixMode.Wrap) &&
ShouldWrapAndIndent(containingNode, i))
{
textChanges.Add(
(trailing.Any() && trailing.Last().IsWhitespaceTrivia())
? trailing.Last().Span
: new TextSpan(token.FullSpan.End, 0),
endOfLine);
textChanges.Add(new TextSpan(node.FullSpan.Start, 0), increasedIndentation);
indentationAdded = true;
}
}
ImmutableArray <IndentationInfo> indentations = FindIndentations(node, node.Span).ToImmutableArray();
if (!indentations.Any())
{
continue;
}
LambdaBlock lambdaBlock2 = GetLambdaBlock(node, lines ??= node.SyntaxTree.GetText().Lines);
bool isLambdaBlockWithOpenBraceAtEndOfLine = lambdaBlock2.Token == indentations.Last().Token;
int baseIndentationLength = (isLambdaBlockWithOpenBraceAtEndOfLine)
? indentations.Last().Span.Length
: indentations[0].Span.Length;
for (int j = indentations.Length - 1; j >= 0; j--)
{
IndentationInfo indentationInfo = indentations[j];
if (indentationAdded &&
node is ArgumentSyntax argument &&
(argument.Expression as AnonymousFunctionExpressionSyntax)?.Block != null)
{
indentationAdded = false;
}
string replacement = increasedIndentation;
if (indentationAdded)
{
replacement += indentationAnalysis.GetSingleIndentation();
}
if ((j > 0 || isLambdaBlockWithOpenBraceAtEndOfLine) &&
indentationInfo.Span.Length > baseIndentationLength)
{
replacement += indentationInfo.ToString().Substring(baseIndentationLength);
}
if (indentationInfo.Span.Length != replacement.Length)
{
textChanges.Add(indentationInfo.Span, replacement);
}
}
}
FormattingVerifier.VerifyChangedSpansAreWhitespace(containingNode, textChanges);
return(textChanges);
}
public ICEPExpression <InputType> Where(Func <InputType, bool> whereFunc)
{
LambdaBlock <InputType> block = blockFactory.CreateLambdaBlock(whereFunc, name + "Where");
return(CreateChildExpr <InputType>(this, block, name + "Where."));
}
