Method parseTypeParameter

internal/parser/parser.go:3233–3263

()

}

func (p *Parser) parseTypeParameter() *ast.Node {
	pos := p.nodePos()
	modifiers := p.parseModifiersEx(false /*allowDecorators*/, true /*permitConstAsModifier*/, false /*stopOnStartOfClassStaticBlock*/)
	name := p.parseIdentifier()
	var constraint *ast.TypeNode
	var expression *ast.Expression
	if p.parseOptional(ast.KindExtendsKeyword) {
		// It's not uncommon for people to write improper constraints to a generic.  If the
		// user writes a constraint that is an expression and not an actual type, then parse
		// it out as an expression (so we can recover well), but report that a type is needed
		// instead.
		if p.isStartOfType(false /*inStartOfParameter*/) || !p.isStartOfExpression() {
			constraint = p.parseType()
		} else {
			// It was not a type, and it looked like an expression.  Parse out an expression
			// here so we recover well.  Note: it is important that we call parseUnaryExpression
			// and not parseExpression here.  If the user has:
			//
			//      <T extends "">
			//
			// We do *not* want to consume the `>` as we're consuming the expression for "".
			expression = p.parseUnaryExpressionOrHigher()
		}
	}
	var defaultType *ast.TypeNode
	if p.parseOptional(ast.KindEqualsToken) {
		defaultType = p.parseType()
	}
	result := p.factory.NewTypeParameterDeclaration(modifiers, name, constraint, expression, defaultType)
	return p.finishNode(result, pos)
}

func (p *Parser) parseParameters(flags ParseFlags) *ast.NodeList {
	// FormalParameters [Yield,Await]: (modified)