diff --git a/pkg/analyzer/test/generated/parser_test.dart b/pkg/analyzer/test/generated/parser_test.dart
index 0024e05..e7298b6 100644
--- a/pkg/analyzer/test/generated/parser_test.dart
+++ b/pkg/analyzer/test/generated/parser_test.dart
@@ -17917,6 +17917,21 @@
     expect(alias.semicolon, isNotNull);
   }
 
+  void test_parseGenericTypeAlias_typeParameters2() {
+    // The scanner creates a single token for `>=`
+    // then the parser must split it into two separate tokens.
+    createParser('typedef F<T>= T Function(T);');
+    GenericTypeAlias alias = parseFullCompilationUnitMember();
+    expect(alias, isNotNull);
+    assertNoErrors();
+    expect(alias.name, isNotNull);
+    expect(alias.name.name, 'F');
+    expect(alias.typeParameters, isNotNull);
+    expect(alias.equals, isNotNull);
+    expect(alias.functionType, isNotNull);
+    expect(alias.semicolon, isNotNull);
+  }
+
   void test_parseImportDirective_configuration_multiple() {
     createParser("import 'lib/lib.dart' if (a) 'b.dart' if (c) 'd.dart';");
     ImportDirective directive = parseFullDirective();
diff --git a/pkg/front_end/lib/src/fasta/parser/parser.dart b/pkg/front_end/lib/src/fasta/parser/parser.dart
index 01b159d..d0e4017 100644
--- a/pkg/front_end/lib/src/fasta/parser/parser.dart
+++ b/pkg/front_end/lib/src/fasta/parser/parser.dart
@@ -1060,7 +1060,7 @@
     TypeInfo typeInfo = computeType(typedefKeyword, false);
     token = typeInfo.skipType(typedefKeyword).next;
     Token equals;
-    TypeParamOrArgInfo typeParam = computeTypeParamOrArg(token);
+    TypeParamOrArgInfo typeParam = computeTypeParamOrArg(token, true);
     if (typeInfo == noType &&
         (token.kind == IDENTIFIER_TOKEN || token.type.isPseudo) &&
         optional('=', typeParam.skip(token).next)) {
diff --git a/pkg/front_end/lib/src/fasta/parser/token_stream_rewriter.dart b/pkg/front_end/lib/src/fasta/parser/token_stream_rewriter.dart
index e3ae092..0c8d710 100644
--- a/pkg/front_end/lib/src/fasta/parser/token_stream_rewriter.dart
+++ b/pkg/front_end/lib/src/fasta/parser/token_stream_rewriter.dart
@@ -14,7 +14,8 @@
         Token,
         TokenType;
 
-import 'util.dart' show optional;
+import 'util.dart'
+    show optional, splitGtEq, splitGtGt, splitGtGtEq, syntheticGt;
 
 /// Provides the capability of inserting tokens into a token stream. This
 /// implementation does this by rewriting the previous token to point to the
@@ -143,20 +144,13 @@
 
     Token gt;
     if (optional('>>', end)) {
-      gt = new SimpleToken(TokenType.GT, end.charOffset, end.precedingComments)
-        ..setNext(new SimpleToken(TokenType.GT, end.charOffset + 1)
-          ..setNext(end.next));
+      gt = splitGtGt(end);
     } else if (optional('>=', end)) {
-      gt = new SimpleToken(TokenType.GT, end.charOffset, end.precedingComments)
-        ..setNext(new SimpleToken(TokenType.EQ, end.charOffset + 1)
-          ..setNext(end.next));
+      gt = splitGtEq(end);
     } else if (optional('>>=', end)) {
-      gt = new SimpleToken(TokenType.GT, end.charOffset, end.precedingComments)
-        ..setNext(new SimpleToken(TokenType.GT, end.charOffset + 1)
-          ..setNext(new SimpleToken(TokenType.EQ, end.charOffset + 2)
-            ..setNext(end.next)));
+      gt = splitGtGtEq(end);
     } else {
-      gt = new SyntheticToken(TokenType.GT, end.charOffset)..setNext(end);
+      gt = syntheticGt(end);
     }
 
     Token token = start;
diff --git a/pkg/front_end/lib/src/fasta/parser/type_info.dart b/pkg/front_end/lib/src/fasta/parser/type_info.dart
index c94e6f4..19d5bd6 100644
--- a/pkg/front_end/lib/src/fasta/parser/type_info.dart
+++ b/pkg/front_end/lib/src/fasta/parser/type_info.dart
@@ -59,6 +59,17 @@
 /// [computeTypeParamOrArg] about a particular group of type arguments
 /// or type parameters.
 abstract class TypeParamOrArgInfo {
+  const TypeParamOrArgInfo();
+
+  /// Return `true` if the receiver represents a single type argument
+  bool get isSimpleTypeArgument => false;
+
+  /// Return the simple type associated with this simple type argument
+  /// or throw an exception if this is not a simple type argument.
+  TypeInfo get typeInfo {
+    throw "Internal error: $runtimeType is not a SimpleTypeArgument.";
+  }
+
   /// Call this function to parse optional type arguments after [token].
   /// This function will call the appropriate event methods on the [Parser]'s
   /// listener to handle the arguments. This may modify the token stream
@@ -82,31 +93,13 @@
 /// there is no type information in the source.
 const TypeInfo noType = const NoType();
 
-/// [VoidType] is a specialized [TypeInfo] returned by [computeType] when
-/// there is a single identifier as the type reference.
-const TypeInfo voidType = const VoidType();
-
-/// [SimpleType] is a specialized [TypeInfo] returned by [computeType]
-/// when there is a single identifier as the type reference.
-const TypeInfo simpleType = const SimpleType();
-
-/// [PrefixedType] is a specialized [TypeInfo] returned by [computeType]
-/// when the type reference is of the form: identifier `.` identifier.
-const TypeInfo prefixedType = const PrefixedType();
-
-/// [SimpleTypeWith1Argument] is a specialized [TypeInfo] returned by
-/// [computeType] when the type reference is of the form:
-/// identifier `<` identifier `>`.
-const TypeInfo simpleTypeWith1Argument = const SimpleTypeWith1Argument();
-
 /// [NoTypeParamOrArg] is a specialized [TypeParamOrArgInfo] returned by
 /// [computeTypeParamOrArg] when no type parameters or arguments are found.
 const TypeParamOrArgInfo noTypeParamOrArg = const NoTypeParamOrArg();
 
-/// [SimpleTypeArgument1] is a specialized [TypeParamOrArgInfo] returned by
-/// [computeTypeParamOrArg] when the type reference is of the form:
-/// `<` identifier `>`.
-const TypeParamOrArgInfo simpleTypeArgument1 = const SimpleTypeArgument1();
+/// [VoidType] is a specialized [TypeInfo] returned by [computeType] when
+/// there is a single identifier as the type reference.
+const TypeInfo voidType = const VoidType();
 
 bool isGeneralizedFunctionType(Token token) {
   return optional('Function', token) &&
@@ -191,13 +184,13 @@
   TypeParamOrArgInfo typeParamOrArg =
       computeTypeParamOrArg(next, inDeclaration, innerEndGroup);
   if (typeParamOrArg != noTypeParamOrArg) {
-    if (typeParamOrArg == simpleTypeArgument1) {
+    if (typeParamOrArg.isSimpleTypeArgument) {
       // We've seen identifier `<` identifier `>`
       next = typeParamOrArg.skip(next).next;
       if (!isGeneralizedFunctionType(next)) {
         if (required || looksLikeName(next)) {
           // identifier `<` identifier `>` identifier
-          return simpleTypeWith1Argument;
+          return typeParamOrArg.typeInfo;
         } else {
           // identifier `<` identifier `>` non-identifier
           return noType;
@@ -272,28 +265,33 @@
 /// has not been split or the first `>` if the `>>` token has been split.
 TypeParamOrArgInfo computeTypeParamOrArg(Token token,
     [bool inDeclaration = false, Token innerEndGroup]) {
-  Token next = token.next;
-  if (!optional('<', next)) {
+  Token beginGroup = token.next;
+  if (!optional('<', beginGroup)) {
     return noTypeParamOrArg;
   }
-  Token endGroup = next.endGroup ?? innerEndGroup;
+  Token endGroup = beginGroup.endGroup ?? innerEndGroup;
   if (endGroup == null) {
-    if (inDeclaration) {
-      // Recovery
-      // Since the leading `<` cannot be part of an expression,
-      // try to more aggressively recover given an unbalanced '<'.
-      return new ComplexTypeParamOrArgInfo(token, inDeclaration)
-          .compute(innerEndGroup);
+    if (!inDeclaration) {
+      return noTypeParamOrArg;
     }
-    return noTypeParamOrArg;
+    // Recovery:
+    // Since the leading `<` cannot be part of an expression, fall through and
+    // try to more aggressively recover given an unbalanced '<'.
   }
-  Token identifier = next.next;
+
   // identifier `<` `void` `>` and `<` `dynamic` `>`
   // are handled by ComplexTypeInfo.
-  if ((identifier.kind == IDENTIFIER_TOKEN || identifier.type.isPseudo) &&
-      identifier.next == endGroup) {
-    return simpleTypeArgument1;
+  Token identifier = beginGroup.next;
+  if ((identifier.kind == IDENTIFIER_TOKEN || identifier.type.isPseudo)) {
+    if (optional('>', identifier.next)) {
+      return simpleTypeArgument1;
+    } else if (optional('>>', identifier.next)) {
+      return simpleTypeArgument1GtGt;
+    } else if (optional('>=', identifier.next)) {
+      return simpleTypeArgument1GtEq;
+    }
   }
+
   // TODO(danrubel): Consider adding additional const for common situations.
   return new ComplexTypeParamOrArgInfo(token, inDeclaration)
       .compute(innerEndGroup);
diff --git a/pkg/front_end/lib/src/fasta/parser/type_info_impl.dart b/pkg/front_end/lib/src/fasta/parser/type_info_impl.dart
index 3ec6155..e3bb31c 100644
--- a/pkg/front_end/lib/src/fasta/parser/type_info_impl.dart
+++ b/pkg/front_end/lib/src/fasta/parser/type_info_impl.dart
@@ -23,7 +23,50 @@
 
 import 'type_info.dart';
 
-import 'util.dart' show isOneOf, optional, skipMetadata;
+import 'util.dart' show isOneOf, optional, skipMetadata, splitGtEq, splitGtGt;
+
+/// [SimpleType] is a specialized [TypeInfo] returned by [computeType]
+/// when there is a single identifier as the type reference.
+const TypeInfo simpleType = const SimpleType();
+
+/// [PrefixedType] is a specialized [TypeInfo] returned by [computeType]
+/// when the type reference is of the form: identifier `.` identifier.
+const TypeInfo prefixedType = const PrefixedType();
+
+/// [SimpleTypeWith1Argument] is a specialized [TypeInfo] returned by
+/// [computeType] when the type reference is of the form:
+/// identifier `<` identifier `>`.
+const TypeInfo simpleTypeWith1Argument =
+    const SimpleTypeWith1Argument(simpleTypeArgument1);
+
+/// [SimpleTypeWith1Argument] is a specialized [TypeInfo] returned by
+/// [computeType] when the type reference is of the form:
+/// identifier `<` identifier `>=`.
+const TypeInfo simpleTypeWith1ArgumentGtEq =
+    const SimpleTypeWith1Argument(simpleTypeArgument1GtEq);
+
+/// [SimpleTypeWith1Argument] is a specialized [TypeInfo] returned by
+/// [computeType] when the type reference is of the form:
+/// identifier `<` identifier `>>`.
+const TypeInfo simpleTypeWith1ArgumentGtGt =
+    const SimpleTypeWith1Argument(simpleTypeArgument1GtGt);
+
+/// [SimpleTypeArgument1] is a specialized [TypeParamOrArgInfo] returned by
+/// [computeTypeParamOrArg] when the type reference is of the form:
+/// `<` identifier `>`.
+const TypeParamOrArgInfo simpleTypeArgument1 = const SimpleTypeArgument1();
+
+/// [SimpleTypeArgument1] is a specialized [TypeParamOrArgInfo] returned by
+/// [computeTypeParamOrArg] when the type reference is of the form:
+/// `<` identifier `>=`.
+const TypeParamOrArgInfo simpleTypeArgument1GtEq =
+    const SimpleTypeArgument1GtEq();
+
+/// [SimpleTypeArgument1] is a specialized [TypeParamOrArgInfo] returned by
+/// [computeTypeParamOrArg] when the type reference is of the form:
+/// `<` identifier `>>`.
+const TypeParamOrArgInfo simpleTypeArgument1GtGt =
+    const SimpleTypeArgument1GtGt();
 
 /// See documentation on the [noType] const.
 class NoType implements TypeInfo {
@@ -108,7 +151,9 @@
 
 /// See documentation on the [simpleTypeWith1Argument] const.
 class SimpleTypeWith1Argument implements TypeInfo {
-  const SimpleTypeWith1Argument();
+  final TypeParamOrArgInfo typeArg;
+
+  const SimpleTypeWith1Argument(this.typeArg);
 
   @override
   bool get couldBeExpression => false;
@@ -131,7 +176,7 @@
     assert(token.isKeywordOrIdentifier);
     Listener listener = parser.listener;
     listener.handleIdentifier(token, IdentifierContext.typeReference);
-    token = simpleTypeArgument1.parseArguments(token, parser);
+    token = typeArg.parseArguments(token, parser);
     listener.handleType(start, token.next);
     return token;
   }
@@ -140,7 +185,7 @@
   Token skipType(Token token) {
     token = token.next;
     assert(token.isKeywordOrIdentifier);
-    return simpleTypeArgument1.skip(token);
+    return typeArg.skip(token);
   }
 }
 
@@ -470,7 +515,7 @@
 }
 
 /// See [noTypeParamOrArg].
-class NoTypeParamOrArg implements TypeParamOrArgInfo {
+class NoTypeParamOrArg extends TypeParamOrArgInfo {
   const NoTypeParamOrArg();
 
   @override
@@ -489,37 +534,43 @@
   Token skip(Token token) => token;
 }
 
-class SimpleTypeArgument1 implements TypeParamOrArgInfo {
+class SimpleTypeArgument1 extends TypeParamOrArgInfo {
   const SimpleTypeArgument1();
 
   @override
+  bool get isSimpleTypeArgument => true;
+
+  @override
+  TypeInfo get typeInfo => simpleTypeWith1Argument;
+
+  @override
   Token parseArguments(Token token, Parser parser) {
-    BeginToken start = token = token.next;
-    assert(optional('<', token));
+    BeginToken beginGroup = token.next;
+    assert(optional('<', beginGroup));
     Listener listener = parser.listener;
-    listener.beginTypeArguments(token);
-    token = simpleType.parseType(token, parser);
-    token = processEndGroup(token, start, parser);
-    parser.listener.endTypeArguments(1, start, token);
+    listener.beginTypeArguments(beginGroup);
+    token = simpleType.parseType(beginGroup, parser);
+    token = updateEndGroup(beginGroup, token);
+    parser.listener.endTypeArguments(1, beginGroup, token);
     return token;
   }
 
   @override
   Token parseVariables(Token token, Parser parser) {
-    BeginToken start = token = token.next;
-    assert(optional('<', token));
+    BeginToken beginGroup = token.next;
+    assert(optional('<', beginGroup));
     Listener listener = parser.listener;
-    listener.beginTypeVariables(token);
-    token = token.next;
+    listener.beginTypeVariables(beginGroup);
+    token = beginGroup.next;
     listener.beginMetadataStar(token);
     listener.endMetadataStar(0);
     listener.handleIdentifier(token, IdentifierContext.typeVariableDeclaration);
     listener.beginTypeVariable(token);
     listener.handleTypeVariablesDefined(token, 1);
     listener.handleNoType(token);
-    token = processEndGroup(token, start, parser);
+    token = updateEndGroup(beginGroup, token);
     listener.endTypeVariable(token, 0, null);
-    listener.endTypeVariables(start, token);
+    listener.endTypeVariables(beginGroup, token);
     return token;
   }
 
@@ -527,15 +578,68 @@
   Token skip(Token token) {
     token = token.next;
     assert(optional('<', token));
-    assert(token.endGroup != null ||
-        (optional('>', token.next.next) || optional('>>', token.next.next)));
-    return (optional('>', token.endGroup ?? token.next.next)
-        ? token.next.next
-        : token.next);
+    token = token.next;
+    assert(token.isKeywordOrIdentifier);
+    return skipEndGroup(token);
+  }
+
+  Token skipEndGroup(Token token) {
+    token = token.next;
+    assert(optional('>', token));
+    return token;
+  }
+
+  Token updateEndGroup(BeginToken beginGroup, Token token) {
+    token = token.next;
+    assert(optional('>', token));
+    beginGroup.endGroup = token;
+    return token;
   }
 }
 
-class ComplexTypeParamOrArgInfo implements TypeParamOrArgInfo {
+class SimpleTypeArgument1GtEq extends SimpleTypeArgument1 {
+  const SimpleTypeArgument1GtEq();
+
+  @override
+  TypeInfo get typeInfo => simpleTypeWith1ArgumentGtEq;
+
+  Token skipEndGroup(Token token) {
+    token = token.next;
+    assert(optional('>=', token));
+    return splitGtEq(token);
+  }
+
+  Token updateEndGroup(BeginToken beginGroup, Token beforeEndGroup) {
+    Token endGroup = beforeEndGroup.next;
+    assert(optional('>=', endGroup));
+    beginGroup.endGroup = endGroup = splitGtEq(endGroup);
+    beforeEndGroup.setNext(endGroup);
+    return endGroup;
+  }
+}
+
+class SimpleTypeArgument1GtGt extends SimpleTypeArgument1 {
+  const SimpleTypeArgument1GtGt();
+
+  @override
+  TypeInfo get typeInfo => simpleTypeWith1ArgumentGtGt;
+
+  Token skipEndGroup(Token token) {
+    assert(optional('>>', token.next));
+    return token;
+  }
+
+  Token updateEndGroup(BeginToken beginGroup, Token beforeEndGroup) {
+    Token endGroup = beforeEndGroup.next;
+    if (!optional('>', endGroup)) {
+      endGroup = splitGtGt(endGroup);
+    }
+    beginGroup.endGroup = endGroup;
+    return endGroup;
+  }
+}
+
+class ComplexTypeParamOrArgInfo extends TypeParamOrArgInfo {
   /// The first token in the type var.
   final BeginToken start;
 
diff --git a/pkg/front_end/lib/src/fasta/parser/util.dart b/pkg/front_end/lib/src/fasta/parser/util.dart
index 4329810..7d57ecd 100644
--- a/pkg/front_end/lib/src/fasta/parser/util.dart
+++ b/pkg/front_end/lib/src/fasta/parser/util.dart
@@ -10,7 +10,8 @@
 
 import '../scanner.dart' show Token;
 
-import '../../scanner/token.dart' show BeginToken;
+import '../../scanner/token.dart'
+    show BeginToken, SimpleToken, SyntheticToken, TokenType;
 
 /// Returns true if [token] is the symbol or keyword [value].
 bool optional(String value, Token token) {
@@ -127,3 +128,44 @@
   }
   return token;
 }
+
+/// Split `>=` into two separate tokens.
+Token splitGtEq(Token token) {
+  assert(optional('>=', token));
+  return new SimpleToken(
+      TokenType.GT, token.charOffset, token.precedingComments)
+    ..setNext(new SimpleToken(TokenType.EQ, token.charOffset + 1)
+      ..setNext(token.next));
+}
+
+/// Split `>>` into two separate tokens.
+SimpleToken splitGtGt(Token token) {
+  assert(optional('>>', token));
+  return new SimpleToken(
+      TokenType.GT, token.charOffset, token.precedingComments)
+    ..setNext(new SimpleToken(TokenType.GT, token.charOffset + 1)
+      ..setNext(token.next));
+}
+
+/// Split `>>=` into three separate tokens.
+Token splitGtGtEq(Token token) {
+  assert(optional('>>=', token));
+  return new SimpleToken(
+      TokenType.GT, token.charOffset, token.precedingComments)
+    ..setNext(new SimpleToken(TokenType.GT, token.charOffset + 1)
+      ..setNext(new SimpleToken(TokenType.EQ, token.charOffset + 2)
+        ..setNext(token.next)));
+}
+
+/// Split `>>=` into two separate tokens... `>` followed by `>=`.
+Token splitGtFromGtGtEq(Token token) {
+  assert(optional('>>=', token));
+  return new SimpleToken(
+      TokenType.GT, token.charOffset, token.precedingComments)
+    ..setNext(new SimpleToken(TokenType.GT_EQ, token.charOffset + 1)
+      ..setNext(token.next));
+}
+
+Token syntheticGt(Token token) {
+  return new SyntheticToken(TokenType.GT, token.charOffset)..setNext(token);
+}
diff --git a/pkg/front_end/test/fasta/parser/type_info_test.dart b/pkg/front_end/test/fasta/parser/type_info_test.dart
index 6cde453..453b0b0 100644
--- a/pkg/front_end/test/fasta/parser/type_info_test.dart
+++ b/pkg/front_end/test/fasta/parser/type_info_test.dart
@@ -580,7 +580,7 @@
 
   void test_computeType_nested() {
     expectNestedInfo(simpleType, '<T>');
-    expectNestedInfo(simpleTypeWith1Argument, '<T<S>>');
+    expectNestedInfo(simpleTypeWith1ArgumentGtGt, '<T<S>>');
     expectNestedComplexInfo('<T<S,R>>');
     expectNestedComplexInfo('<T<S Function()>>');
     expectNestedComplexInfo('<T<S Function()>>');
@@ -837,7 +837,18 @@
     Token t = start.next.next;
     expect(t.next.lexeme, '>>');
 
-    expect(simpleTypeArgument1.skip(start), t);
+    expect(simpleTypeArgument1GtGt.skip(start), t);
+  }
+
+  void test_simple_skip3() {
+    final Token start = scanString('before <T>= after').tokens;
+    Token t = start.next.next;
+    expect(t.next.lexeme, '>=');
+
+    Token skip = simpleTypeArgument1GtEq.skip(start);
+    expect(skip.lexeme, '>');
+    expect(skip.next.lexeme, '=');
+    expect(skip.next.next, t.next.next);
   }
 
   void test_simple_parseArguments() {
@@ -891,6 +902,10 @@
     expectTypeParamOrArg(simpleTypeArgument1, '<T>');
   }
 
+  void test_computeTypeParamOrArg_simple2() {
+    expectTypeParamOrArg(simpleTypeArgument1GtEq, '<T>=', inDeclaration: true);
+  }
+
   void test_computeTypeParamOrArg_simple_nested() {
     String source = '<C<T>>';
     Token start = scan(source).next.next;
@@ -899,7 +914,7 @@
     expect(gtgt.lexeme, '>>');
 
     TypeParamOrArgInfo typeVarInfo = computeTypeParamOrArg(start, false, gtgt);
-    expect(typeVarInfo, simpleTypeArgument1, reason: source);
+    expect(typeVarInfo, simpleTypeArgument1GtGt, reason: source);
   }
 
   void test_computeTypeArg_complex() {