Expose UriQueryExpressionParser.ParseFilter as a public API (#805)

Expose UriQueryExpressionParser and QueryToken object model publicly

Author: m-abdelmonem

src/Microsoft.OData.Client/ALinq/ResourceBinder.cs

@@ -21,7 +21,8 @@ namespace Microsoft.OData.Client
     using Microsoft.OData;
     using Microsoft.OData.UriParser;
     using Microsoft.OData.Edm;
-
+    using PathSegmentToken = Microsoft.OData.Client.ALinq.UriParser.PathSegmentToken;
+    using NonSystemToken = Microsoft.OData.Client.ALinq.UriParser.NonSystemToken;
     #endregion Namespaces
 
     /// 

src/Microsoft.OData.Client/Build.Portable/Microsoft.OData.Client.Portable.csproj

@@ -160,8 +160,8 @@
     <Compile Include="$(EnlistmentRoot)\src\Microsoft.OData.Core\UriParser\SyntacticAst\QueryToken.cs">
       <Link>ALinq\UriParser\SyntacticAst\QueryToken.csLink>
     Compile>
-    <Compile Include="$(EnlistmentRoot)\src\Microsoft.OData.Core\UriParser\TreeNodeKinds\QueryTokenKind.cs">
-      <Link>ALinq\UriParser\TreeNodeKinds\QueryTokenKind.csLink>
+    <Compile Include="$(EnlistmentRoot)\src\Microsoft.OData.Core\UriParser\SyntacticAst\QueryTokenKind.cs">
+      <Link>ALinq\UriParser\SyntacticAst\QueryTokenKind.csLink>
     Compile>
     <Compile Include="$(EnlistmentRoot)\src\Microsoft.OData.Core\UriParser\SyntacticAst\RangeVariableToken.cs">
       <Link>ALinq\UriParser\SyntacticAst\RangeVariableToken.csLink>

src/Microsoft.OData.Client/Microsoft.OData.Client.csproj

@@ -166,8 +166,8 @@
     <Compile Include="$(EnlistmentRoot)\src\Microsoft.OData.Core\UriParser\SyntacticAst\QueryToken.cs">
       <Link>ALinq\UriParser\SyntacticAst\QueryToken.csLink>
     Compile>
-    <Compile Include="$(EnlistmentRoot)\src\Microsoft.OData.Core\UriParser\TreeNodeKinds\QueryTokenKind.cs">
-      <Link>ALinq\UriParser\TreeNodeKinds\QueryTokenKind.csLink>
+    <Compile Include="$(EnlistmentRoot)\src\Microsoft.OData.Core\UriParser\SyntacticAst\QueryTokenKind.cs">
+      <Link>ALinq\UriParser\SyntacticAst\QueryTokenKind.csLink>
     Compile>
     <Compile Include="$(EnlistmentRoot)\src\Microsoft.OData.Core\UriParser\SyntacticAst\RangeVariableToken.cs">
       <Link>ALinq\UriParser\SyntacticAst\RangeVariableToken.csLink>

src/Microsoft.OData.Core/Build.Net35/Microsoft.OData.Core.NetFX35.csproj

@@ -1312,6 +1312,9 @@
     <Compile Include="$(ODataCrossTargettingSourcePath)\UriParser\SyntacticAst\QueryToken.cs">
       <Link>Microsoft\OData\Core\UriParser\SyntacticAst\QueryToken.csLink>
     Compile>
+    <Compile Include="$(ODataCrossTargettingSourcePath)\UriParser\SyntacticAst\QueryTokenKind.cs">
+      <Link>Microsoft\OData\Core\UriParser\SyntacticAst\QueryTokenKind.csLink>
+    Compile>	
     <Compile Include="$(ODataCrossTargettingSourcePath)\UriParser\SyntacticAst\RangeVariableToken.cs">
       <Link>Microsoft\OData\Core\UriParser\SyntacticAst\RangeVariableToken.csLink>
     Compile>
@@ -1339,9 +1342,6 @@
     <Compile Include="$(ODataCrossTargettingSourcePath)\UriParser\TreeNodeKinds\QueryNodeKind.cs">
       <Link>Microsoft\OData\Core\UriParser\TreeNodeKinds\QueryNodeKind.csLink>
     Compile>
-    <Compile Include="$(ODataCrossTargettingSourcePath)\UriParser\TreeNodeKinds\QueryTokenKind.cs">
-      <Link>Microsoft\OData\Core\UriParser\TreeNodeKinds\QueryTokenKind.csLink>
-    Compile>
     <Compile Include="$(ODataCrossTargettingSourcePath)\UriParser\TreeNodeKinds\RequestTargetKind.cs">
       <Link>Microsoft\OData\Core\UriParser\TreeNodeKinds\RequestTargetKind.csLink>
     Compile>

src/Microsoft.OData.Core/Microsoft.OData.Core.csproj

@@ -542,7 +542,7 @@
     <Compile Include="UriParser\TreeNodeKinds\BinaryOperatorKind.cs" />
     <Compile Include="UriParser\TreeNodeKinds\ExpressionTokenKind.cs" />
     <Compile Include="UriParser\TreeNodeKinds\QueryNodeKind.cs" />
-    <Compile Include="UriParser\TreeNodeKinds\QueryTokenKind.cs" />
+    <Compile Include="UriParser\SyntacticAst\QueryTokenKind.cs" />
     <Compile Include="UriParser\TreeNodeKinds\RequestTargetKind.cs" />
     <Compile Include="UriParser\TreeNodeKinds\UnaryOperatorKind.cs" />
     <Compile Include="UriParser\TypePromotionUtils.cs" />

src/Microsoft.OData.Core/UriParser/Aggregation/AggregateExpressionToken.cs

@@ -14,7 +14,10 @@ namespace Microsoft.OData.UriParser.Aggregation
 #endif
     using Microsoft.OData.UriParser;
 
-    internal sealed class AggregateExpressionToken : QueryToken
+    /// 
+    /// Query token representing an Aggregate expression.
+    /// 
+    public sealed class AggregateExpressionToken : QueryToken
     {
         private readonly QueryToken expression;
 
@@ -24,6 +27,12 @@ internal sealed class AggregateExpressionToken : QueryToken
 
         private readonly string alias;
 
+        /// 
+        /// Create an AggregateExpressionToken.
+        /// 
+        /// The aggregate expression.
+        /// The aggregation method.
+        /// The alias for this query token.
         public AggregateExpressionToken(QueryToken expression, AggregationMethod method, string alias)
         {
             ExceptionUtils.CheckArgumentNotNull(expression, "expression");
@@ -34,32 +43,53 @@ public AggregateExpressionToken(QueryToken expression, AggregationMethod method,
             this.alias = alias;
         }
 
+        /// 
+        /// Create an AggregateExpressionToken.
+        /// 
+        /// The aggregate expression.
+        /// The aggregate method definition.
+        /// The alias for this query token.
         public AggregateExpressionToken(QueryToken expression, AggregationMethodDefinition methodDefinition, string alias)
             : this(expression, methodDefinition.MethodKind, alias)
         {
             this.methodDefinition = methodDefinition;
         }
 
+        /// 
+        /// Gets the kind of this token.
+        /// 
         public override QueryTokenKind Kind
         {
             get { return QueryTokenKind.AggregateExpression; }
         }
 
+        /// 
+        /// Gets the AggregationMethod of this token.
+        /// 
         public AggregationMethod Method
         {
             get { return this.method; }
         }
 
+        /// 
+        /// Gets the aggregate method definition.
+        /// 
         public AggregationMethodDefinition MethodDefinition
         {
             get { return this.methodDefinition; }
         }
 
+        /// 
+        /// Gets the expression.
+        /// 
         public QueryToken Expression
         {
             get { return this.expression; }
         }
 
+        /// 
+        /// Gets the alias.
+        /// 
         public string Alias
         {
             get { return this.alias; }

src/Microsoft.OData.Core/UriParser/Aggregation/AggregateToken.cs

@@ -13,21 +13,34 @@ namespace Microsoft.OData.UriParser.Aggregation
     using System.Collections.Generic;
     using Microsoft.OData.UriParser;
 
-    internal sealed class AggregateToken : ApplyTransformationToken
+    /// 
+    /// Query token representing an Aggregate token.
+    /// 
+    public sealed class AggregateToken : ApplyTransformationToken
     {
         private readonly IEnumerable<AggregateExpressionToken> expressions;
 
+        /// 
+        /// Create an AggregateToken.
+        /// 
+        /// The list of AggregateExpressionToken.
         public AggregateToken(IEnumerable<AggregateExpressionToken> expressions)
         {
             ExceptionUtils.CheckArgumentNotNull(expressions, "expressions");
             this.expressions = expressions;
         }
 
+        /// 
+        /// Gets the kind of this token.
+        /// 
         public override QueryTokenKind Kind
         {
             get { return QueryTokenKind.Aggregate; }
         }
 
+        /// 
+        /// Gets the list of AggregateExpressionToken.
+        /// 
         public IEnumerable<AggregateExpressionToken> Expressions
         {
             get

src/Microsoft.OData.Core/UriParser/Aggregation/ApplyTransformationToken.cs

@@ -15,7 +15,7 @@ namespace Microsoft.OData.UriParser.Aggregation
     /// 
     /// Base class for Apply transformation tokens
     /// 
-    internal abstract class ApplyTransformationToken : QueryToken
+    public abstract class ApplyTransformationToken : QueryToken
     {
     }
 }

src/Microsoft.OData.Core/UriParser/Aggregation/GroupByToken.cs

@@ -13,12 +13,20 @@ namespace Microsoft.OData.UriParser.Aggregation
     using System.Collections.Generic;
     using Microsoft.OData.UriParser;
 
-    internal sealed class GroupByToken : ApplyTransformationToken
+    /// 
+    /// Query token representing a GroupBy token.
+    /// 
+    public sealed class GroupByToken : ApplyTransformationToken
     {
         private readonly IEnumerable<EndPathToken> properties;
 
         private readonly ApplyTransformationToken child;
 
+        /// 
+        /// Create a GroupByToken.
+        /// 
+        /// The list of group by properties.
+        /// The child of this token.
         public GroupByToken(IEnumerable<EndPathToken> properties, ApplyTransformationToken child)
         {
             ExceptionUtils.CheckArgumentNotNull(properties, "properties");
@@ -28,18 +36,24 @@ public GroupByToken(IEnumerable properties, ApplyTransformationTok
         }
 
         /// 
-        /// The kind of the query token.
+        /// Gets the kind of this token.
         /// 
         public override QueryTokenKind Kind
         {
             get { return QueryTokenKind.AggregateGroupBy; }
         }
 
+        /// 
+        /// Gets the list of group by properties.
+        /// 
         public IEnumerable<EndPathToken> Properties
         {
             get { return this.properties; }
         }
 
+        /// 
+        /// Gets the child of this token.
+        /// 
         public ApplyTransformationToken Child
         {
             get { return this.child; }

src/Microsoft.OData.Core/UriParser/Binders/ExpandTreeNormalizer.cs

@@ -44,7 +44,7 @@ public ExpandToken NormalizePaths(ExpandToken treeToInvert)
             foreach (ExpandTermToken term in treeToInvert.ExpandTerms)
             {
                 PathReverser pathReverser = new PathReverser();
-                PathSegmentToken reversedPath = term.PathToNavProp.Accept(pathReverser);
+                PathSegmentToken reversedPath = term.PathToNavigationProp.Accept(pathReverser);
 
                 // we also need to call the select token normalizer for this level to reverse the select paths
                 SelectToken newSelectToken = term.SelectOption;
@@ -86,7 +86,7 @@ public ExpandToken CombineTerms(ExpandToken treeToCollapse)
                 {
                     ExpandToken newSubExpand = CombineTerms(termToken.ExpandOption);
                     finalTermToken = new ExpandTermToken(
-                                                              termToken.PathToNavProp,
+                                                              termToken.PathToNavigationProp,
                                                               termToken.FilterOption,
                                                               termToken.OrderByOptions,
                                                               termToken.TopOption,
@@ -112,12 +112,12 @@ public ExpandToken CombineTerms(ExpandToken treeToCollapse)
         /// the combined token, or, if the two are mutually exclusive, the same tokens
         public ExpandTermToken CombineTerms(ExpandTermToken existingToken, ExpandTermToken newToken)
         {
-            Debug.Assert(new PathSegmentTokenEqualityComparer().Equals(existingToken.PathToNavProp, newToken.PathToNavProp), "Paths should be equal.");
+            Debug.Assert(new PathSegmentTokenEqualityComparer().Equals(existingToken.PathToNavigationProp, newToken.PathToNavigationProp), "Paths should be equal.");
 
             List<ExpandTermToken> childNodes = CombineChildNodes(existingToken, newToken).ToList();
             SelectToken combinedSelects = CombineSelects(existingToken, newToken);
             return new ExpandTermToken(
-                    existingToken.PathToNavProp,
+                    existingToken.PathToNavigationProp,
                     existingToken.FilterOption,
                     existingToken.OrderByOptions,
                     existingToken.TopOption,
         private void AddOrCombine(IDictionary<PathSegmentToken, ExpandTermToken> combinedTerms, ExpandTermToken expandedTerm)
         {
             ExpandTermToken existingTerm;
-            if (combinedTerms.TryGetValue(expandedTerm.PathToNavProp, out existingTerm))
+            if (combinedTerms.TryGetValue(expandedTerm.PathToNavigationProp, out existingTerm))
             {
-                combinedTerms[expandedTerm.PathToNavProp] = CombineTerms(expandedTerm, existingTerm);
+                combinedTerms[expandedTerm.PathToNavigationProp] = CombineTerms(expandedTerm, existingTerm);
             }
             else
             {
-                combinedTerms.Add(expandedTerm.PathToNavProp, expandedTerm);
+                combinedTerms.Add(expandedTerm.PathToNavigationProp, expandedTerm);
             }
         }