| // Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file |
| // for details. All rights reserved. Use of this source code is governed by a |
| // BSD-style license that can be found in the LICENSE file. |
| |
| library fasta.parser.type_info; |
| |
| import '../../scanner/token.dart' show Token, TokenType; |
| |
| import '../scanner/token_constants.dart' show IDENTIFIER_TOKEN, KEYWORD_TOKEN; |
| |
| import '../util/link.dart' show Link; |
| |
| import 'identifier_context.dart' show IdentifierContext; |
| |
| import 'listener.dart' show Listener; |
| |
| import 'member_kind.dart' show MemberKind; |
| |
| import 'parser.dart' show Parser; |
| |
| import 'type_info_impl.dart' |
| show |
| NoTypeInfo, |
| PrefixedTypeInfo, |
| SimpleTypeArgumentsInfo, |
| SimpleTypeInfo, |
| VoidTypeInfo, |
| looksLikeName, |
| skipTypeArguments; |
| |
| import 'util.dart' show optional; |
| |
| /// [TypeInfo] provides information that has collected by [computeType] |
| /// about a particular type reference. |
| abstract class TypeInfo { |
| /// Call this function when it's known that the token after [token] is a type. |
| /// This function will call the appropriate event methods on the [Parser]'s |
| /// listener to handle the type. |
| Token parseType(Token token, Parser parser); |
| |
| /// Call this function with the [token] before the type to obtain |
| /// the last token in the type. If there is no type, then this method |
| /// will return [token]. |
| Token skipType(Token token); |
| } |
| |
| /// [NoTypeInfo] is a specialized [TypeInfo] returned by [computeType] when |
| /// there is no type information in the source. |
| const TypeInfo noTypeInfo = const NoTypeInfo(); |
| |
| /// [VoidTypeInfo] is a specialized [TypeInfo] returned by [computeType] when |
| /// there is a single identifier as the type reference. |
| const TypeInfo voidTypeInfo = const VoidTypeInfo(); |
| |
| /// [SimpleTypeInfo] is a specialized [TypeInfo] returned by [computeType] |
| /// when there is a single identifier as the type reference. |
| const TypeInfo simpleTypeInfo = const SimpleTypeInfo(); |
| |
| /// [PrefixedTypeInfo] is a specialized [TypeInfo] returned by [computeType] |
| /// when the type reference is of the form: identifier `.` identifier. |
| const TypeInfo prefixedTypeInfo = const PrefixedTypeInfo(); |
| |
| /// [SimpleTypeArgumentsInfo] is a specialized [TypeInfo] returned by |
| /// [computeType] when the type reference is of the form: |
| /// identifier `<` identifier `>`. |
| const TypeInfo simpleTypeArgumentsInfo = const SimpleTypeArgumentsInfo(); |
| |
| bool isGeneralizedFunctionType(Token token) { |
| return optional('Function', token) && |
| (optional('<', token.next) || optional('(', token.next)); |
| } |
| |
| bool isValidTypeReference(Token token) { |
| int kind = token.kind; |
| if (IDENTIFIER_TOKEN == kind) return true; |
| if (KEYWORD_TOKEN == kind) { |
| TokenType type = token.type; |
| String value = type.lexeme; |
| return type.isPseudo || |
| (type.isBuiltIn && optional('.', token.next)) || |
| (identical(value, 'dynamic')) || |
| (identical(value, 'void')); |
| } |
| return false; |
| } |
| |
| /// Called by the parser to obtain information about a possible type reference |
| /// that follows [token]. |
| TypeInfo computeType(final Token token, bool required) { |
| Token next = token.next; |
| if (!isValidTypeReference(next)) { |
| return noTypeInfo; |
| } |
| |
| if (optional('void', next)) { |
| next = next.next; |
| if (isGeneralizedFunctionType(next)) { |
| // `void` `Function` ... |
| return new ComplexTypeInfo(token).computeVoidGFT(required); |
| } |
| // `void` |
| return voidTypeInfo; |
| } |
| |
| if (isGeneralizedFunctionType(next)) { |
| // `Function` ... |
| return new ComplexTypeInfo(token).computeNoTypeGFT(required); |
| } |
| |
| // We've seen an identifier. |
| next = next.next; |
| |
| if (optional('<', next)) { |
| if (next.endGroup != null) { |
| next = next.next; |
| // identifier `<` `void` `>` is handled by ComplexTypeInfo. |
| if (isValidTypeReference(next) && !identical('void', next.stringValue)) { |
| next = next.next; |
| if (optional('>', next)) { |
| // We've seen identifier `<` identifier `>` |
| next = next.next; |
| if (!isGeneralizedFunctionType(next)) { |
| if (required || looksLikeName(next)) { |
| // identifier `<` identifier `>` identifier |
| return simpleTypeArgumentsInfo; |
| } else { |
| // identifier `<` identifier `>` non-identifier |
| return noTypeInfo; |
| } |
| } |
| } |
| // TODO(danrubel): Consider adding a const for |
| // identifier `<` identifier `,` identifier `>` |
| // if that proves to be a common case. |
| } |
| |
| // identifier `<` ... `>` |
| return new ComplexTypeInfo(token) |
| .computeSimpleWithTypeArguments(required); |
| } |
| // identifier `<` |
| return required ? simpleTypeInfo : noTypeInfo; |
| } |
| |
| if (optional('.', next)) { |
| next = next.next; |
| if (isValidTypeReference(next)) { |
| next = next.next; |
| // We've seen identifier `.` identifier |
| if (!optional('<', next) && !isGeneralizedFunctionType(next)) { |
| if (required || looksLikeName(next)) { |
| // identifier `.` identifier identifier |
| return prefixedTypeInfo; |
| } else { |
| // identifier `.` identifier non-identifier |
| return noTypeInfo; |
| } |
| } |
| // identifier `.` identifier |
| return new ComplexTypeInfo(token).computePrefixedType(required); |
| } |
| // identifier `.` non-identifier |
| return required ? simpleTypeInfo : noTypeInfo; |
| } |
| |
| if (isGeneralizedFunctionType(next)) { |
| // `Function` |
| return new ComplexTypeInfo(token).computeIdentifierGFT(required); |
| } |
| |
| if (required || looksLikeName(next)) { |
| // identifier identifier |
| return simpleTypeInfo; |
| } |
| return noTypeInfo; |
| } |
| |
| /// Instances of [ComplexTypeInfo] are returned by [computeType] to represent |
| /// type references that cannot be represented by the constants above. |
| class ComplexTypeInfo implements TypeInfo { |
| final Token start; |
| Token end; |
| |
| /// Non-null if type arguments were seen during analysis. |
| Token typeArguments; |
| |
| /// The tokens before the start of type variables of function types seen |
| /// during analysis. Notice that the tokens in this list might precede |
| /// either `'<'` or `'('` as not all function types have type parameters. |
| Link<Token> typeVariableStarters = const Link<Token>(); |
| |
| /// If the receiver represents a generalized function type then this indicates |
| /// whether it has a return type, otherwise this is `null`. |
| bool gftHasReturnType; |
| |
| ComplexTypeInfo(Token beforeStart) : this.start = beforeStart.next; |
| |
| @override |
| Token parseType(Token token, Parser parser) { |
| assert(identical(token.next, start)); |
| Listener listener = parser.listener; |
| |
| for (Link<Token> t = typeVariableStarters; t.isNotEmpty; t = t.tail) { |
| parser.parseTypeVariablesOpt(t.head); |
| listener.beginFunctionType(start); |
| } |
| |
| if (gftHasReturnType == false) { |
| // A function type without return type. |
| // Push the non-existing return type first. The loop below will |
| // generate the full type. |
| noTypeInfo.parseType(token, parser); |
| } else if (optional('void', token.next)) { |
| token = voidTypeInfo.parseType(token, parser); |
| } else { |
| if (!optional('.', token.next.next)) { |
| token = parser.ensureIdentifier(token, IdentifierContext.typeReference); |
| } else { |
| token = parser.ensureIdentifier( |
| token, IdentifierContext.prefixedTypeReference); |
| token = parser.parseQualifiedRest( |
| token, IdentifierContext.typeReferenceContinuation); |
| } |
| token = parser.parseTypeArgumentsOpt(token); |
| listener.handleType(start, token.next); |
| } |
| |
| for (Link<Token> t = typeVariableStarters; t.isNotEmpty; t = t.tail) { |
| token = token.next; |
| assert(optional('Function', token)); |
| Token functionToken = token; |
| if (optional("<", token.next)) { |
| // Skip type parameters, they were parsed above. |
| token = token.next.endGroup; |
| } |
| token = parser.parseFormalParametersRequiredOpt( |
| token, MemberKind.GeneralizedFunctionType); |
| listener.endFunctionType(functionToken, token.next); |
| } |
| |
| assert( |
| identical(token, end) || (optional('>', token) && optional('>>', end))); |
| return token; |
| } |
| |
| @override |
| Token skipType(Token token) { |
| return end; |
| } |
| |
| /// Given `Function` non-identifier, compute the type |
| /// and return the receiver or one of the [TypeInfo] constants. |
| TypeInfo computeNoTypeGFT(bool required) { |
| assert(optional('Function', start)); |
| computeRest(start, required); |
| |
| return gftHasReturnType != null |
| ? this |
| : required ? simpleTypeInfo : noTypeInfo; |
| } |
| |
| /// Given void `Function` non-identifier, compute the type |
| /// and return the receiver or one of the [TypeInfo] constants. |
| TypeInfo computeVoidGFT(bool required) { |
| assert(optional('void', start)); |
| assert(optional('Function', start.next)); |
| computeRest(start.next, required); |
| |
| return gftHasReturnType != null ? this : voidTypeInfo; |
| } |
| |
| /// Given identifier `Function` non-identifier, compute the type |
| /// and return the receiver or one of the [TypeInfo] constants. |
| TypeInfo computeIdentifierGFT(bool required) { |
| assert(isValidTypeReference(start)); |
| assert(optional('Function', start.next)); |
| computeRest(start.next, required); |
| |
| return gftHasReturnType != null ? this : simpleTypeInfo; |
| } |
| |
| /// Given identifier `<` ... `>`, compute the type |
| /// and return the receiver or one of the [TypeInfo] constants. |
| TypeInfo computeSimpleWithTypeArguments(bool required) { |
| assert(isValidTypeReference(start)); |
| typeArguments = start.next; |
| assert(optional('<', typeArguments)); |
| |
| Token token = skipTypeArguments(typeArguments); |
| if (token == null) { |
| return required ? simpleTypeInfo : noTypeInfo; |
| } |
| end = token; |
| computeRest(token.next, required); |
| |
| return required || looksLikeName(end.next) || gftHasReturnType != null |
| ? this |
| : noTypeInfo; |
| } |
| |
| /// Given identifier `.` identifier, compute the type |
| /// and return the receiver or one of the [TypeInfo] constants. |
| TypeInfo computePrefixedType(bool required) { |
| assert(isValidTypeReference(start)); |
| Token token = start.next; |
| assert(optional('.', token)); |
| token = token.next; |
| assert(isValidTypeReference(token)); |
| |
| end = token; |
| token = token.next; |
| if (optional('<', token)) { |
| typeArguments = token; |
| token = skipTypeArguments(token); |
| if (token == null) { |
| return required ? prefixedTypeInfo : noTypeInfo; |
| } |
| end = token; |
| token = token.next; |
| } |
| computeRest(token, required); |
| |
| return required || looksLikeName(end.next) || gftHasReturnType != null |
| ? this |
| : noTypeInfo; |
| } |
| |
| void computeRest(Token token, bool required) { |
| while (optional('Function', token)) { |
| Token typeVariableStart = token; |
| token = token.next; |
| if (optional('<', token)) { |
| token = token.endGroup; |
| if (token == null) { |
| break; // Not a function type. |
| } |
| assert(optional('>', token) || optional('>>', token)); |
| token = token.next; |
| } |
| if (!optional('(', token)) { |
| break; // Not a function type. |
| } |
| token = token.endGroup; |
| if (token == null) { |
| break; // Not a function type. |
| } |
| assert(optional(')', token)); |
| gftHasReturnType ??= typeVariableStart != start; |
| typeVariableStarters = typeVariableStarters.prepend(typeVariableStart); |
| end = token; |
| token = token.next; |
| } |
| } |
| } |