type-bounds in not a valid type

nois.bnf

@@ -96,7 +96,7 @@ identifier            ::= (NAME COLON COLON)* NAME type-args?
                       ;
   type-args           ::= O-ANGLE (type (COMMA type)* COMMA?)? C-ANGLE
                       ;
-type                  ::= type-bounds | fn-type | hole
+type                  ::= identifier | fn-type | hole
                       ;
   type-bounds         ::= identifier (PLUS identifier)*
                       ;

src/ast/index.ts

@@ -57,7 +57,7 @@ import {
     buildStatement,
     buildUseExpr
 } from './statement'
-import { FnType, Generic, Type, TypeBounds, buildType } from './type'
+import { FnType, Generic, Type, buildType } from './type'
 import { FieldDef, TypeDef, Variant } from './type-def'
 
 export type AstNode =
@@ -69,7 +69,6 @@ export type AstNode =
     | Arg
     | Block
     | Param
-    | TypeBounds
     | FnType
     | Generic
     | IfExpr

src/ast/type.ts

@@ -5,19 +5,14 @@ import { Checked } from '../semantic'
 import { Hole, buildHole } from './match'
 import { Identifier, Name, buildIdentifier, buildName } from './operand'
 
-export type Type = (Identifier | TypeBounds | FnType | Hole) & Partial<Checked>
+export type Type = (Identifier | FnType | Hole) & Partial<Checked>
 
 export const buildType = (node: ParseNode, ctx: Context): Type => {
     const n = filterNonAstNodes(node)[0]
     if (node.kind === 'type-annot') {
         return buildType(n, ctx)
-    } else if (n.kind === 'type-bounds') {
-        const typeBounds = buildTypeBounds(n, ctx)
-        if (typeBounds.bounds.length === 1) {
-            return typeBounds.bounds[0]
-        } else {
-            return typeBounds
-        }
+    } else if (n.kind === 'identifier') {
+        return buildIdentifier(n, ctx)
     } else if (n.kind === 'hole') {
         return buildHole(n)
     } else {

src/parser/fns/type.ts

@@ -16,12 +16,12 @@ export const parseTypeAnnot = (parser: Parser): void => {
 }
 
 /**
- * type ::= type-bounds | fn-type | hole
+ * type ::= identifier | fn-type | hole
  */
 export const parseType = (parser: Parser): void => {
     const mark = parser.open()
     if (parser.atAny(nameLikeTokens)) {
-        parseTypeBounds(parser)
+        parseIdentifier(parser)
     } else if (parser.atAny(['pipe', 'o-angle'])) {
         parseFnType(parser)
     } else if (parser.at('underscore')) {

src/phase/name-resolve.ts

@@ -34,10 +34,6 @@ export const resolveName = (node: AstNode, ctx: Context): void => {
             }
             break
         }
-        case 'type-bounds': {
-            node.bounds.forEach(b => resolveName(b, ctx))
-            break
-        }
         case 'fn-type': {
             resolveName(node.returnType, ctx)
             node.paramTypes.forEach(pt => resolveName(pt, ctx))