public void ShouldWriteSummary() { var example = new ExampleResult { Reason = Resources.TestReason, ElapsedTime = 1000, Message = "Test Exception", StackTrace = "System.InvalidOperationException: Test Exception", Status = ResultStatus.Error }; var results = new Collection<ExpressionResult>(); var expression = new ExpressionResult(); var group = new ExampleGroupResult(); group.Examples.Add(example); expression.Examples.Add(group); results.Add(expression); this.consoleFormatter.WriteError(example); this.consoleFormatter.WriteSummary(results); this.stringWriter.Flush(); var value = "F" + Environment.NewLine + Environment.NewLine + "Failures:" + Environment.NewLine + Environment.NewLine + "1) test" + Environment.NewLine + " Failure/Error: System.InvalidOperationException: Test Exception" + Environment.NewLine + Environment.NewLine + "Finished in 1 seconds" + Environment.NewLine + "1 examples, 1 failures" + Environment.NewLine; this.stringWriter.ToString().Should().Be(value); }
public void Indexer1() { const string program = @"using System; class Main { public int this[" ; ExpressionResult result = ef.FindExpression(program, program.Length); Assert.AreEqual(CSharpExpressionContext.ParameterType, result.Context); }
public void MultipleFieldsWithInitializers() { const string program = @"using System; class MyClass { int field1 = 1, "; ExpressionResult result = ef.FindExpression(program, program.Length); Assert.AreEqual(null, result.Expression); Assert.AreEqual(ExpressionContext.IdentifierExpected, result.Context); }
public void FieldArrayInitializer() { const string program = @"using System; class Main { int[] myField = { " ; ExpressionResult result = ef.FindExpression(program, program.Length); Assert.AreEqual(ExpressionContext.Default, result.Context); }
public void GenericMethodTest6() { const string program = @"using System; class T { void Test<T>(ref T name) where "; ExpressionResult result = ef.FindExpression(program, program.Length); Assert.AreEqual("where ", result.Expression); Assert.AreEqual(CSharpExpressionContext.Constraints, result.Context); }
public void FieldInGenericClass() { const string program = @"using System; class MyList<T> where T : IComparable<T> { List<T> "; ExpressionResult result = ef.FindExpression(program, program.Length); Assert.AreEqual("List<T> ", result.Expression); Assert.AreEqual(ExpressionContext.IdentifierExpected, result.Context); }
public void GenericMethodTest3() { const string program = @"using System; class T { void Test<T>(ref "; ExpressionResult result = ef.FindExpression(program, program.Length); Assert.IsNull(result.Expression); Assert.AreEqual(CSharpExpressionContext.ParameterType, result.Context); }
public void GenericMethodTest4() { const string program = @"using System; class T { void Test<T>(ref T "; ExpressionResult result = ef.FindExpression(program, program.Length); Assert.AreEqual("T ", result.Expression); Assert.AreEqual(ExpressionContext.IdentifierExpected, result.Context); }
public void GenericDelegateTest5() { const string program = @"using System; delegate void Test<T>(ref T name) "; ExpressionResult result = ef.FindExpression(program, program.Length); Assert.AreEqual("Test<T>(ref T name) ", result.Expression); Assert.AreEqual(CSharpExpressionContext.ConstraintsStart, result.Context); }
public void GenericDelegateTest2() { const string program = @"using System; delegate void Test<T>("; ExpressionResult result = ef.FindExpression(program, program.Length); Assert.IsNull(result.Expression); Assert.AreEqual(CSharpExpressionContext.ParameterType, result.Context); }
public void GenericDelegateTest1() { const string program = @"using System; delegate void Test<"; ExpressionResult result = ef.FindExpression(program, program.Length); Assert.IsNull(result.Expression); Assert.AreEqual(ExpressionContext.IdentifierExpected, result.Context); }
public void BlockLambdaInField() { const string program = @"using System; class Main { Func<int, int> f = a => { " ; ExpressionResult result = ef.FindExpression(program, program.Length); Assert.AreEqual(ExpressionContext.MethodBody, result.Context); }
public void Indexer2() { const string program = @"using System; class Main { public int this[int index] { " ; ExpressionResult result = ef.FindExpression(program, program.Length); Assert.AreEqual(CSharpExpressionContext.PropertyDeclaration, result.Context); }
public void DelegateTest1() { const string program = @"using System; delegate "; ExpressionResult result = ef.FindExpression(program, program.Length); Assert.AreEqual("delegate ", result.Expression); Assert.AreEqual(ExpressionContext.Type, result.Context); }
public override string FormatLogicalExpression(ExpressionBuilderParams p, ExpressionResult left, IOperator op, ExpressionResult right, EvaluationStatement template) { return(FormatLogicalExpression(p, left.TypeDescriptor, left.Expression, op, right.TypeDescriptor, right.Expression, template)); }
/// <inheritdoc/> public override ICompletionItemList GenerateCompletionList(ITextEditor editor) { if (editor == null) { throw new ArgumentNullException("textEditor"); } ExpressionResult expression = GetExpression(editor); return(GenerateCompletionListForExpression(editor, expression)); }
public ExpressionResult FindExpression(string inText, int offset) { ExpressionResult r = FindExpressionInternal(inText, offset); if (string.IsNullOrEmpty(r.Expression)) { r.Expression = null; } return(r); }
public ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult) { IClass matchingClass = GetClass(resolverContext, expressionResult.Expression); if (matchingClass != null) { return(CreateTypeResolveResult(matchingClass)); } return(null); }
public void MultipleLinesWithImportAndNamespace() { string text = "# Line to ignore\r\n" + "import System"; ExpressionResult result = expressionFinder.FindExpression(text, text.Length); Assert.AreEqual("import System", result.Expression); Assert.IsNotNull(result.Context as PythonImportExpressionContext); }
public IActionResult Index() { var anyExample = new AnyExpression().GetExampleQuery(_context); var includeExample = new IncludeExpression().GetExampleQuery(_context); var andOrExample = new AndOrExpression().GetExampleQuery(_context); var result = new ExpressionResult(anyExample.ToList(), includeExample.ToList(), andOrExample.ToList()); return(View(result)); }
protected override void GenerateCompletionData(TextArea textArea, char charTyped) { if (forceNewExpression) { preSelection = ""; if (charTyped != '\0') { preSelection = null; } ExpressionContext context = overrideContext; if (context == null) { context = ExpressionContext.Default; } AddResolveResults(ParserService.CtrlSpace(caretLineNumber, caretColumn, fileName, textArea.Document.TextContent, context), context); return; } ExpressionResult expressionResult = GetExpression(textArea); string expression = expressionResult.Expression; preSelection = null; if (expression == null || expression.Length == 0) { preSelection = ""; if (charTyped != '\0') { preSelection = null; } AddResolveResults(ParserService.CtrlSpace(caretLineNumber, caretColumn, fileName, textArea.Document.TextContent, expressionResult.Context), expressionResult.Context); return; } int idx = expression.LastIndexOf('.'); if (idx > 0) { preSelection = expression.Substring(idx + 1); expressionResult.Expression = expression.Substring(0, idx); if (charTyped != '\0') { preSelection = null; } GenerateCompletionData(textArea, expressionResult); } else { preSelection = expression; if (charTyped != '\0') { preSelection = null; } AddResolveResults(ParserService.CtrlSpace(caretLineNumber, caretColumn, fileName, textArea.Document.TextContent, expressionResult.Context), expressionResult.Context); } }
public void TestGetResultAsBoolean(object value, bool expectedValue) { // Arrange var sut = new ExpressionResult(value); // Act var result = sut.GetValueAsBoolean(); // Assert Assert.AreEqual(expectedValue, result); }
ExpressionResult GetExpressionAt(ITextEditor editor, int caretLine, int caretColumn) { ExpressionResult expr = ParserService.FindFullExpression(caretLine, caretColumn, editor.Document, editor.FileName); // if no expression, look one character back (works better with method calls, e.g. Foo()(*caret*)) if (string.IsNullOrWhiteSpace(expr.Expression) && caretColumn > 1) { expr = ParserService.FindFullExpression(caretLine, caretColumn - 1, editor.Document, editor.FileName); } return(expr); }
public void InsideStringLiteral() { const string program = @"using System; class Main { string a = ""hello, " ; ExpressionResult result = ef.FindExpression(program, program.Length); Assert.IsNull(result.Expression); Assert.AreEqual(ExpressionContext.Default, result.Context); }
public override ResolveResult Resolve(ITextEditor editor, ExpressionResult expressionResult) { // bypass ParserService.Resolve and set resolver.LimitMethodExtractionUntilCaretLine ParseInformation parseInfo = ParserService.GetParseInformation(editor.Document.Text, ProjectContent); var resolver = new NRefactoryResolver(LanguageProperties.CSharp) { LimitMethodExtractionUntilLine = editor.Caret.Line }; return(resolver.Resolve(expressionResult, parseInfo, editor.Document.Text)); }
public void BlockLambdaInCondition() { const string program = @"using System; class Main { void M() { if (Method(a => { " ; ExpressionResult result = ef.FindExpression(program, program.Length); Assert.AreEqual(ExpressionContext.MethodBody, result.Context); }
public void IndexerAccessInObjectInitializer() { const string program = @"using System; class Main { void M() { a = new SomeObject { b = c[ " ; ExpressionResult result = ef.FindExpression(program, program.Length); Assert.AreEqual(ExpressionContext.Default, result.Context); }
public void ContextInCall() { const string program = @"using System; class Main { void M() { MethodCall( " ; ExpressionResult result = ef.FindExpression(program, program.Length); Assert.AreEqual(ExpressionContext.Default, result.Context); }
public void ArrayInitializer2() { const string program = @"using System; class Main { void M() { a = new SomeType [] { " ; ExpressionResult result = ef.FindExpression(program, program.Length); Assert.AreEqual(ExpressionContext.MethodBody, result.Context); }
public void ObjectInitializer8b() { const string program = @"using System; class Main { void M() { a = new SomeType { SomeProperty = new SomeOtherType { " ; ExpressionResult result = ef.FindExpression(program, program.Length); Assert.AreEqual(CSharpExpressionContext.ObjectInitializer, result.Context); }
public void ObjectInitializer7() { const string program = @"using System; class Main { void M() { a = new { a.B, " ; ExpressionResult result = ef.FindExpression(program, program.Length); Assert.AreEqual(CSharpExpressionContext.ObjectInitializer, result.Context); }
public void ObjectInitializer5b() { const string program = @"using System; class Main { void M() { a = new MyType { P1 = someBoolean == " ; ExpressionResult result = ef.FindExpression(program, program.Length); Assert.AreEqual(ExpressionContext.Default, result.Context); }
/// <summary> /// Evaluate the specified expression and return the result. /// </summary> /// <remarks> /// <para> /// This implementation is hard-coded to return an <see cref="ExpressionResult"/> which indicates an evaluation /// failure. /// </para> /// </remarks> /// <param name="expression">The expression to evaluate.</param> /// <param name="element">The element for which we are evaluating a result.</param> public override ExpressionResult Evaluate(string expression, IRenderingContext context) { object result; ExpressionResult output; if(this.TryGetItem(expression, context, out result)) { output = new ExpressionResult(result); } else { string message = String.Format("The item '{0}' was not found in the model.", expression); throw new InvalidOperationException(message); } return output; }
/// <summary> /// Coerces an expression result to a boolean value. /// </summary> /// <returns><c>true</c>, if the expression result indicates truth, <c>false</c> otherwise.</returns> /// <param name="result">An expression result.</param> private bool CoerceToBoolean(ExpressionResult result) { if(result == null) { throw new ArgumentNullException(nameof(result)); } bool output; if(result.CancelsAction) { output = false; } else if(result.Value == null) { output = false; } else if(result.Value is bool) { output = (bool) result.Value; } else if(result.Value.Equals(0)) { output = false; } else if(result.Value is IEnumerable) { var enumerableValue = ((IEnumerable) result.Value).Cast<object>(); output = enumerableValue.Any(); } else if(result.Value is ITalesConvertible) { var convertibleValue = (ITalesConvertible) result.Value; output = convertibleValue.AsBoolean(); } else { output = true; } return output; }
public override ExpressionResult Evaluate(string expression, IRenderingContext context) { object result; ExpressionResult output; if(this.TryGetItem(expression, context, out result)) { output = new ExpressionResult(result); } else { string message = String.Format(Resources.ExceptionMessages.ModelDoesNotContainItem, expression); throw new ModelEvaluationException(message) { ElementName = context.Element.Name, ExpressionText = expression.ToString(), }; } return output; }
private static void CreateExamples(ExpressionResult expression, ICollection<testsuiteType> groupTypes) { foreach (var group in expression.Examples) { var hasGroupErrors = group.Examples.HasErrors(); var groupType = new testsuiteType { name = group.Reason, type = "TestFixture", result = hasGroupErrors ? "Failure" : "Success", executed = bool.TrueString, time = ConvertToSeconds(group.Examples.ElapsedTime()).ToString(CultureInfo.InvariantCulture), asserts = "0", success = hasGroupErrors ? bool.FalseString : bool.TrueString }; var cases = new Collection<testcaseType>(); CreateErrors(group, cases); CreateSuccesses(group, cases); groupType.results = cases.ToArray(); groupTypes.Add(groupType); } }
public ExpressionResult Execute(Expression expression, string exampleText) { var expressionResult = new ExpressionResult { Name = expression.Name }; foreach (var exampleGroup in expression.FindExampleGroup(exampleText)) { expressionResult.Examples.Add(ExecuteExampleGroup(exampleGroup)); return expressionResult; } foreach (var example in expression.FindExample(exampleText)) { var exampleResult = new ExampleGroupResult { Reason = example.ExampleGroup.Reason }; exampleResult.Examples.Add(ExecuteExample(example.ExampleGroup, example.Example)); expressionResult.Examples.Add(exampleResult); return expressionResult; } expression.Examples.ForEach(group => expressionResult.Examples.Add(ExecuteExampleGroup(group))); return expressionResult; }
IEnumerable<ICompletionData> HandleMemberReferenceCompletion(ExpressionResult expr) { if (expr == null) return null; // do not auto select <number>. (but <number>.<number>.) (0.ToString() is valid) if (expr.Node is PrimitiveExpression) { var pexpr = (PrimitiveExpression)expr.Node; if (!(pexpr.Value is string || pexpr.Value is char) && !pexpr.LiteralValue.Contains('.')) { AutoSelect = false; } } var resolveResult = ResolveExpression(expr); if (resolveResult == null) { return null; } if (expr.Node is AstType) { // check for namespace names if (expr.Node.AncestorsAndSelf .TakeWhile(n => n is AstType) .Any(m => m.Role == NamespaceDeclaration.NamespaceNameRole)) return null; // need to look at paren.parent because of "catch (<Type>.A" expression if (expr.Node.Parent != null && expr.Node.Parent.Parent is CatchClause) return HandleCatchClauseType(expr); return CreateTypeAndNamespaceCompletionData( location, resolveResult.Result, expr.Node, resolveResult.Resolver ); } return CreateCompletionData( location, resolveResult.Result, expr.Node, resolveResult.Resolver ); }
IEnumerable<ICompletionData> DefaultControlSpaceItems(ref bool isComplete, ExpressionResult xp = null, bool controlSpace = true) { var wrapper = new CompletionDataWrapper(this); if (offset >= document.TextLength) { offset = document.TextLength - 1; } while (offset > 1 && char.IsWhiteSpace(document.GetCharAt(offset))) { offset--; } location = document.GetLocation(offset); if (xp == null) { xp = GetExpressionAtCursor(); } AstNode node; SyntaxTree unit; ExpressionResolveResult rr; if (xp != null) { node = xp.Node; rr = ResolveExpression(node); unit = xp.Unit; } else { unit = ParseStub("foo", false); node = unit.GetNodeAt( location.Line, location.Column + 2, n => n is Expression || n is AstType || n is NamespaceDeclaration || n is Attribute ); rr = ResolveExpression(node); } var ifvisitor = new IfVisitor(location, CompletionContextProvider); unit.AcceptVisitor(ifvisitor); ifvisitor.End(); if (!ifvisitor.IsValid) return null; // namespace name case var ns = node as NamespaceDeclaration; if (ns != null) { var last = ns.NamespaceName; if (last != null && location < last.EndLocation) return null; } if (node is Identifier && node.Parent is ForeachStatement) { var foreachStmt = (ForeachStatement)node.Parent; foreach (var possibleName in GenerateNameProposals (foreachStmt.VariableType)) { if (possibleName.Length > 0) { wrapper.Result.Add(factory.CreateLiteralCompletionData(possibleName.ToString())); } } AutoSelect = false; AutoCompleteEmptyMatch = false; isComplete = true; return wrapper.Result; } if (node is Identifier && node.Parent is ParameterDeclaration) { if (!controlSpace) { return null; } // Try Parameter name case var param = node.Parent as ParameterDeclaration; if (param != null) { foreach (var possibleName in GenerateNameProposals (param.Type)) { if (possibleName.Length > 0) { wrapper.Result.Add(factory.CreateLiteralCompletionData(possibleName.ToString())); } } AutoSelect = false; AutoCompleteEmptyMatch = false; isComplete = true; return wrapper.Result; } } var pDecl = node as ParameterDeclaration; if (pDecl != null && pDecl.Parent is LambdaExpression) { return null; } /* if (Unit != null && (node == null || node is TypeDeclaration)) { var constructor = Unit.GetNodeAt<ConstructorDeclaration>( location.Line, location.Column - 3 ); if (constructor != null && !constructor.ColonToken.IsNull && constructor.Initializer.IsNull) { wrapper.AddCustom("this"); wrapper.AddCustom("base"); return wrapper.Result; } }*/ var initializer = node != null ? node.Parent as ArrayInitializerExpression : null; if (initializer != null) { var result = HandleObjectInitializer(unit, initializer); if (result != null) return result; } CSharpResolver csResolver = null; if (rr != null) { csResolver = rr.Resolver; } if (csResolver == null) { if (node != null) { csResolver = GetState(); //var astResolver = new CSharpAstResolver (csResolver, node, xp != null ? xp.Item1 : CSharpUnresolvedFile); try { //csResolver = astResolver.GetResolverStateBefore (node); Console.WriteLine(csResolver.LocalVariables.Count()); } catch (Exception e) { Console.WriteLine("E!!!" + e); } } else { csResolver = GetState(); } } if (node is Attribute) { // add attribute properties. var astResolver = CompletionContextProvider.GetResolver(csResolver, unit); var resolved = astResolver.Resolve(node); AddAttributeProperties(wrapper, resolved); } if (node == null) { // try lambda unit = ParseStub("foo) => {}", true); var pd = unit.GetNodeAt<ParameterDeclaration>( location.Line, location.Column ); if (pd != null) { var astResolver = unit != null ? CompletionContextProvider.GetResolver(GetState(), unit) : null; var parameterType = astResolver.Resolve(pd.Type); // Type <name> is always a name context -> return null if (parameterType != null && !parameterType.IsError) return null; } } AddContextCompletion(wrapper, csResolver, node); return wrapper.Result; }
IEnumerable<ICompletionData> HandleCatchClauseType(ExpressionResult identifierStart) { Func<IType, IType> typePred = delegate (IType type) { if (type.GetAllBaseTypes().Any(t => t.ReflectionName == "System.Exception")) return type; return null; }; if (identifierStart.Node.Parent is CatchClause) { var wrapper = new CompletionDataWrapper(this); AddTypesAndNamespaces( wrapper, GetState(), identifierStart.Node, typePred, m => false ); return wrapper.Result; } var resolveResult = ResolveExpression(identifierStart); return CreateCompletionData( location, resolveResult.Result, identifierStart.Node, resolveResult.Resolver, typePred ); }
IEnumerable<ICompletionData> HandleMemberReferenceCompletion(ExpressionResult expr) { if (expr == null) return null; // do not complete <number>. (but <number>.<number>.) if (expr.Node is PrimitiveExpression) { var pexpr = (PrimitiveExpression)expr.Node; if (!(pexpr.Value is string || pexpr.Value is char) && !pexpr.LiteralValue.Contains('.')) { return null; } } var resolveResult = ResolveExpression(expr); if (resolveResult == null) { return null; } if (expr.Node is AstType) { // need to look at paren.parent because of "catch (<Type>.A" expression if (expr.Node.Parent != null && expr.Node.Parent.Parent is CatchClause) return HandleCatchClauseType(expr); return CreateTypeAndNamespaceCompletionData( location, resolveResult.Item1, expr.Node, resolveResult.Item2 ); } return CreateCompletionData( location, resolveResult.Item1, expr.Node, resolveResult.Item2 ); }
IEnumerable<ICompletionData> DefaultControlSpaceItems(ExpressionResult xp = null, bool controlSpace = true) { var wrapper = new CompletionDataWrapper(this); if (offset >= document.TextLength) { offset = document.TextLength - 1; } while (offset > 1 && char.IsWhiteSpace (document.GetCharAt (offset))) { offset--; } location = document.GetLocation(offset); if (xp == null) { xp = GetExpressionAtCursor(); } AstNode node; CompilationUnit unit; Tuple<ResolveResult, CSharpResolver> rr; if (xp != null) { node = xp.Node; rr = ResolveExpression(node, xp.Unit); unit = xp.Unit; } else { unit = ParseStub("foo", false); node = unit.GetNodeAt( location.Line, location.Column + 2, n => n is Expression || n is AstType ); rr = ResolveExpression(node, unit); } if (node is Identifier && node.Parent is ForeachStatement) { var foreachStmt = (ForeachStatement)node.Parent; foreach (var possibleName in GenerateNameProposals (foreachStmt.VariableType)) { if (possibleName.Length > 0) { wrapper.Result.Add(factory.CreateLiteralCompletionData(possibleName.ToString())); } } AutoSelect = false; AutoCompleteEmptyMatch = false; return wrapper.Result; } if (node is Identifier && node.Parent is ParameterDeclaration) { if (!controlSpace) { return null; } // Try Parameter name case var param = node.Parent as ParameterDeclaration; if (param != null) { foreach (var possibleName in GenerateNameProposals (param.Type)) { if (possibleName.Length > 0) { wrapper.Result.Add(factory.CreateLiteralCompletionData(possibleName.ToString())); } } AutoSelect = false; AutoCompleteEmptyMatch = false; return wrapper.Result; } } if (Unit != null && (node == null || node is TypeDeclaration)) { var constructor = Unit.GetNodeAt<ConstructorDeclaration>( location.Line, location.Column - 3 ); if (constructor != null && !constructor.ColonToken.IsNull && constructor.Initializer.IsNull) { wrapper.AddCustom("this"); wrapper.AddCustom("base"); return wrapper.Result; } } var initializer = node != null ? node.Parent as ArrayInitializerExpression : null; if (initializer != null) { var result = HandleObjectInitializer(unit, initializer); if (result != null) return result; } CSharpResolver csResolver = null; if (rr != null) { csResolver = rr.Item2; } if (csResolver == null) { if (node != null) { csResolver = GetState(); //var astResolver = new CSharpAstResolver (csResolver, node, xp != null ? xp.Item1 : CSharpParsedFile); try { //csResolver = astResolver.GetResolverStateBefore (node); Console.WriteLine(csResolver.LocalVariables.Count()); } catch (Exception e) { Console.WriteLine("E!!!" + e); } } else { csResolver = GetState(); } } AddContextCompletion(wrapper, csResolver, node, unit); return wrapper.Result; }
protected Tuple<ResolveResult, CSharpResolver> ResolveExpression (ExpressionResult tuple) { return ResolveExpression (tuple.Node); }
public void ShouldWriteSummaryWithOneSuccess() { var results = new Collection<ExpressionResult>(); var result = new ExpressionResult(); var group = new ExampleGroupResult(); var example = new ExampleResult { ElapsedTime = 1000 }; group.Examples.Add(example); result.Examples.Add(group); results.Add(result); consoleFormatter.WriteSummary(results); stringWriter.Flush(); var value = Environment.NewLine + Resources.TestReason + Environment.NewLine + Environment.NewLine + "Finished in 1 seconds" + Environment.NewLine + "1 examples, 0 failures" + Environment.NewLine; stringWriter.ToString().Should().Be(value); }
IEnumerable<ICompletionData> HandleMemberReferenceCompletion(ExpressionResult expr) { if (expr == null) return null; // do not complete <number>. (but <number>.<number>.) if (expr.Node is PrimitiveExpression) { var pexpr = (PrimitiveExpression)expr.Node; if (!(pexpr.Value is string || pexpr.Value is char) && !pexpr.LiteralValue.Contains('.')) { return null; } } var resolveResult = ResolveExpression (expr); if (resolveResult == null) { return null; } if (expr.Node is AstType) { return CreateTypeAndNamespaceCompletionData(location, resolveResult.Item1, expr.Node, resolveResult.Item2); } return CreateCompletionData(location, resolveResult.Item1, expr.Node, resolveResult.Item2); }
protected ExpressionResolveResult ResolveExpression (ExpressionResult tuple) { return ResolveExpression (tuple.Node); }