public Token(TokenId tokenId, string data, Location startLocation, Location endLocation)
 {
     _tokenId = tokenId;
     _data = data;
     _startLocation = startLocation;
     _endLocation = endLocation;
 }

 public BinaryExpression(TokenId op, ExpressionNode left, ExpressionNode right)
     : base(left.RelatedToken)
 {
     _op = op;
     _left = left;
     _right = right;
 }

 public Token(string text, TokenId tokenId, int pos, SourceRange range)
 {
     _text = text;
     _tokenId = tokenId;
     _pos = pos;
     _range = range;
 }

 public MemberAccessExpression(ExpressionNode left, ExpressionNode right, TokenId qualifierKind, bool isMember)
     : base(left.RelatedToken)
 {
     _left = left;
     _right = right;
     _isMember = isMember;
 }

 /// <summary>
 /// Initializes an instance of the Token class.
 /// </summary>
 /// <param name="obj">The object.</param>
 /// <param name="col">The column.</param>
 /// <param name="line">The line.</param>
 /// <param name="pos">The position.</param>
 /// <param name="type">The type.</param>
 public Token(dynamic obj, int col, int line, int pos, TokenId type)
 {
     Object = obj;
     Column = col;
     Line = line;
     Position = pos;
     Type = type;
 }

        private bool Match(TokenId tokenID)
        {
            if (_token.Id == tokenID)
            {
                NextToken();
                return true;
            }

            _errorReporter.TokenExpected(_token.Range, _token.Text, tokenID);
            return false;
        }

        private object EvalBooleanOperator(TokenId op, object lValue)
        {
            bool v = Util.ToBool(lValue);

            switch (op)
            {
                case TokenId.Not: return !v;
            }

            throw new ParseException(string.Format("Unary not support, tokenId: '{0}', value: {1} at line: {2} column:{3}", RelatedToken.TokenId, lValue, RelatedToken.StartLocation.LineIndex + 1, RelatedToken.StartLocation.CharacterIndex + 1));
        }

 private object EvalDecimalOperator(TokenId op, decimal value)
 {
     switch (op)
     {
         case TokenId.Plus:
             return value;
         case TokenId.Minus:
             return -value;
         case TokenId.PlusPlus:
             return ++value;
         case TokenId.MinusMinus:
             return --value;
         default:
             throw new ParseException(string.Format("Unary not support, tokenId: '{0}', value: {1} at line: {2} column:{3}", RelatedToken.TokenId, value, RelatedToken.StartLocation.LineIndex + 1, RelatedToken.StartLocation.CharacterIndex + 1));
     }
 }

 void ValidateToken(TokenId t)
 {
     if (token.id != t) throw ParseError(ErrorMessages.SyntaxError);
 }

 /// <summary>Validates the current token is of the specified kind.</summary>
 /// <param name="t">Expected token kind.</param>
 internal void ValidateToken(TokenId t)
 {
     if (this.token.Id != t)
     {
         throw ParseError(Strings.RequestQueryParser_SyntaxError(this.textPos));
     }
 }

 private void ValidateToken(TokenId t, string errorMessage)
 {
     if (token.id != t) throw ParseError(errorMessage);
 }

 public static TokenInfo FromTokenId(TokenId tokenId)
 {
     return _infosById[tokenId];
 }

 private void ValidateToken(TokenId t)
 {
     if (this._token.Id != t)
         throw this.ParseError("Syntax error", new object[0]);
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="Token"/> class with the specified ID and extension data.
 /// </summary>
 /// <remarks>
 /// <para>This constructor is typically used for authentication requests which specified a <see cref="Token"/>
 /// as the credentials.</para>
 /// </remarks>
 /// <param name="id">The unique ID of the token.</param>
 /// <param name="extensionData">The extension data.</param>
 /// <exception cref="ArgumentNullException">If <paramref name="extensionData"/> is <see langword="null"/>.</exception>
 public Token(TokenId id, ImmutableDictionary<string, JToken> extensionData)
     : base(extensionData)
 {
     _id = id;
 }

 void IErrorReporter.TokenExpected(SourceRange sourceRange, string foundTokenText, TokenId expected)
 {
     string message = String.Format(CultureInfo.CurrentCulture, Resources.TokenExpected, foundTokenText, TokenInfo.FromTokenId(expected).Text);
     HandleError(sourceRange, ErrorId.TokenExpected, message);
 }

 void ValidateToken(TokenId t)
 {
     if (_token.id != t)
     {
         throw ParseError(SRResources.SyntaxError);
     }
 }

		void ValidateToken(TokenId t)
		{
			if (_token.id != t)
				throw CreateParseException(_token.pos, ErrorMessages.SyntaxError);
		}

 static TokenId GetAliasedTokenId(TokenId t, string alias)
 {
     TokenId id;
     return t == TokenId.Identifier && _predefinedAliases.TryGetValue(alias, out id) ? id : t;
 }

 private TokenInfo(TokenId tokenId, string text, bool isKeyword, bool isQueryKeyword, UnaryOperator unOp, BinaryOperator binOp)
 {
     _tokenId = tokenId;
     _text = text;
     _isKeyword = isKeyword;
     _isQueryKeyword = isQueryKeyword;
     _unaryOperator = unOp;
     _binaryOperator = binOp;
 }

        public HttpResponseMessage PostAuthenticate([FromBody] AuthenticationRequest authenticationRequest)
        {
            MediaTypeHeaderValue acceptedType = new MediaTypeHeaderValue("application/json");
            MediaTypeHeaderValue contentType = Request.Content.Headers.ContentType;
            if (!HttpApiCall.IsAcceptable(acceptedType, contentType))
                return new HttpResponseMessage(HttpStatusCode.BadRequest);

            ValidateRequest(Request);

            if (authenticationRequest == null)
                return new HttpResponseMessage(HttpStatusCode.BadRequest);

            AuthenticationData authenticationData = authenticationRequest.AuthenticationData;
            if (authenticationData == null)
                return new HttpResponseMessage(HttpStatusCode.BadRequest);

            if (authenticationData.TenantName != null
                && !string.Equals(authenticationData.TenantName, _tenantName, StringComparison.OrdinalIgnoreCase))
                return new HttpResponseMessage(HttpStatusCode.Unauthorized);

            if (authenticationData.TenantId != null
                && authenticationData.TenantId != new ProjectId(_tenantId))
            {
                return new HttpResponseMessage(HttpStatusCode.Unauthorized);
            }

            if (authenticationData.Token != null)
                throw new NotImplementedException();

            PasswordCredentials passwordCredentials = authenticationData.PasswordCredentials;
            if (passwordCredentials == null)
                return new HttpResponseMessage(HttpStatusCode.BadRequest);

            if (!string.Equals(passwordCredentials.Username, _username, StringComparison.OrdinalIgnoreCase)
                || !string.Equals(passwordCredentials.Password, _password, StringComparison.Ordinal))
            {
                return new HttpResponseMessage(HttpStatusCode.Unauthorized);
            }

            bool hasTenant = authenticationData.TenantId != null || authenticationData.TenantName != null;

            string responseBody;
            if (hasTenant)
                responseBody = IdentityServiceResources.AuthenticateResponseTemplate;
            else
                responseBody = IdentityServiceResources.AuthenticateWithoutTenantResponseTemplate;

            lock (_lock)
            {
                var parameters = new Dictionary<string, string>();

                // expire the token 5 minutes early
                if (!_tokenExpires.HasValue || _tokenExpires < DateTimeOffset.Now - TimeSpan.FromMinutes(5))
                {
                    // generate a new token
                    _tokenCreated = DateTimeOffset.Now;
                    _tokenExpires = _tokenCreated + TimeSpan.FromHours(24);
                    _tokenId = new TokenId(Guid.NewGuid().ToString());
                }

                parameters["issued_at"] = JsonConvert.SerializeObject(_tokenCreated.Value);
                parameters["expires"] = JsonConvert.SerializeObject(_tokenExpires.Value);
                parameters["tokenId"] = JsonConvert.SerializeObject(_tokenId);
                parameters["tenantId"] = JsonConvert.SerializeObject(_tenantId);
                parameters["tenantName"] = JsonConvert.SerializeObject(_tenantName);
                parameters["username"] = JsonConvert.SerializeObject(_username);
                parameters["userId"] = JsonConvert.SerializeObject(_userId);
                parameters["userFullName"] = JsonConvert.SerializeObject(_userFullName);

                foreach (var pair in parameters)
                    responseBody = responseBody.Replace("{" + pair.Key + "}", JsonConvert.DeserializeObject<string>(pair.Value));
            }

            HttpResponseMessage result = new HttpResponseMessage(HttpStatusCode.OK);
            result.Content = new StringContent(responseBody, Encoding.UTF8, "application/json");
            return result;
        }