jaclang 0.2.5__py3-none-any.whl → 0.3.1__py3-none-any.whl

jaclang/jac/transpiler.py

@@ -4,11 +4,7 @@ from typing import Optional, Type
 import jaclang.jac.absyntree as ast
 from jaclang.jac.parser import JacParser
 from jaclang.jac.passes import Pass
-from jaclang.jac.passes.main import (
-    PyOutPass,
-    PyastGenPass,
-    pass_schedule,
-)
+from jaclang.jac.passes.main import PyOutPass, pass_schedule
 from jaclang.jac.passes.tool import JacFormatPass
 from jaclang.jac.passes.tool.schedules import format_pass
 from jaclang.jac.passes.transform import Alert
@@ -18,7 +14,6 @@ def transpile_jac(file_path: str) -> list[Alert]:
     """Transpiler Jac file and return python code as string."""
     code = jac_file_to_pass(
         file_path=file_path,
-        target=PyastGenPass,
         schedule=pass_schedule,
     )
     if isinstance(code.ir, ast.Module) and not code.errors_had:
@@ -30,7 +25,7 @@ def transpile_jac(file_path: str) -> list[Alert]:
 
 def jac_file_to_pass(
     file_path: str,
-    target: Optional[Type[Pass]] = PyastGenPass,
+    target: Optional[Type[Pass]] = None,
     schedule: list[Type[Pass]] = pass_schedule,
 ) -> Pass:
     """Convert a Jac file to an AST."""
@@ -46,7 +41,7 @@ def jac_file_to_pass(
 def jac_str_to_pass(
     jac_str: str,
     file_path: str,
-    target: Optional[Type[Pass]] = PyastGenPass,
+    target: Optional[Type[Pass]] = None,
     schedule: list[Type[Pass]] = pass_schedule,
 ) -> Pass:
     """Convert a Jac file to an AST."""
@@ -64,7 +59,7 @@ def jac_str_to_pass(
 
 def jac_pass_to_pass(
     in_pass: Pass,
-    target: Optional[Type[Pass]] = PyastGenPass,
+    target: Optional[Type[Pass]] = None,
     schedule: list[Type[Pass]] = pass_schedule,
 ) -> Pass:
     """Convert a Jac file to an AST."""

jaclang/utils/helpers.py

@@ -1,11 +1,9 @@
 """Utility functions and classes for Jac compilation toolchain."""
 import re
 import textwrap
-import traceback
 
 
 import jaclang.jac.absyntree as ast
-from jaclang.jac.constant import Constants as Con, Values as Val
 
 
 def pascal_to_snake(pascal_string: str) -> str:
@@ -44,37 +42,6 @@ def dedent_code_block(code: str) -> str:
     return textwrap.dedent(code)
 
 
-def handle_jac_error(code_string: str, e: Exception, tb: traceback.StackSummary) -> str:
-    """Handle Jac Error."""
-    except_line = e.end_lineno if isinstance(e, SyntaxError) else list(tb)[-1].lineno
-    if not isinstance(except_line, int) or except_line == 0:
-        return ""
-    py_error_region = clip_code_section(
-        add_line_numbers(code_string), except_line, Val.JAC_ERROR_LINE_RANGE
-    )
-    try:
-        jac_err_line = int(code_string.splitlines()[except_line - 1].split()[-1])
-        mod_index = int(code_string.splitlines()[except_line - 1].split()[-2])
-        mod_paths = code_string.split(Con.JAC_DEBUG_SPLITTER)[1].strip().splitlines()
-        target_mod = mod_paths[mod_index]
-        with open(target_mod, "r") as file:
-            jac_code_string = file.read()
-        jac_error_region = clip_code_section(
-            add_line_numbers(jac_code_string), jac_err_line, Val.JAC_ERROR_LINE_RANGE
-        )
-        target_mod = f"JacCode File: {target_mod}:{jac_err_line}"
-    except Exception as e:
-        jac_error_region = str(e)
-        target_mod = ""
-    snippet = (
-        f"{Con.JAC_ERROR_PREAMBLE}\n"
-        f"{target_mod}\n"
-        f"JacCode Snippet:\n{jac_error_region}\n"
-        f"PyCode Snippet:\n{py_error_region}\n"
-    )
-    return snippet
-
-
 def get_ast_nodes_as_snake_case() -> list[str]:
     """Get all AST nodes as snake case."""
     import inspect

jaclang/utils/lang_tools.py

@@ -191,6 +191,9 @@ class AstTool:
                 arrow = "-.->" if "Optional" in kid.typ else "-->"
                 typ = (
                     kid.typ.replace("Optional[", "")
+                    .replace("SubNodeList[", "")
+                    .replace("SubTag[", "")
+                    .replace("Sequence[", "")
                     .replace("]", "")
                     .replace("|", ",")
                     .replace("list[", "list - ")

jaclang/utils/test.py

@@ -65,7 +65,9 @@ class TestCaseMicroSuite(ABC, TestCase):
         """Attach micro tests."""
         for filename in [
             os.path.normpath(os.path.join(root, name))
-            for root, _, files in os.walk(os.path.dirname(jaclang.__file__))
+            for root, _, files in os.walk(
+                os.path.dirname(os.path.dirname(jaclang.__file__))
+            )
             for name in files
             if name.endswith(".jac") and not name.startswith("err")
         ]:

jaclang/vendor/mypy/checker.py

@@ -6106,24 +6106,31 @@ class TypeChecker(NodeVisitor[None], CheckerPluginInterface):
                     if node.arg_kinds[0] != nodes.ARG_POS:
                         # the first argument might be used as a kwarg
                         called_type = get_proper_type(self.lookup_type(node.callee))
-                        assert isinstance(called_type, (CallableType, Overloaded))
+
+                        # TODO: there are some more cases in check_call() to handle.
+                        if isinstance(called_type, Instance):
+                            call = find_member(
+                                "__call__", called_type, called_type, is_operator=True
+                            )
+                            if call is not None:
+                                called_type = get_proper_type(call)
 
                         # *assuming* the overloaded function is correct, there's a couple cases:
                         #  1) The first argument has different names, but is pos-only. We don't
                         #     care about this case, the argument must be passed positionally.
                         #  2) The first argument allows keyword reference, therefore must be the
                         #     same between overloads.
-                        name = called_type.items[0].arg_names[0]
-
-                        if name in node.arg_names:
-                            idx = node.arg_names.index(name)
-                            # we want the idx-th variable to be narrowed
-                            expr = collapse_walrus(node.args[idx])
-                        else:
-                            self.fail(
-                                message_registry.TYPE_GUARD_POS_ARG_REQUIRED, node
-                            )
-                            return {}, {}
+                        if isinstance(called_type, (CallableType, Overloaded)):
+                            name = called_type.items[0].arg_names[0]
+                            if name in node.arg_names:
+                                idx = node.arg_names.index(name)
+                                # we want the idx-th variable to be narrowed
+                                expr = collapse_walrus(node.args[idx])
+                            else:
+                                self.fail(
+                                    message_registry.TYPE_GUARD_POS_ARG_REQUIRED, node
+                                )
+                                return {}, {}
                     if literal(expr) == LITERAL_TYPE:
                         # Note: we wrap the target type, so that we can special case later.
                         # Namely, for isinstance() we use a normal meet, while TypeGuard is

jaclang/vendor/mypy/checkexpr.py

@@ -3870,8 +3870,9 @@ class ExpressionChecker(ExpressionVisitor[Type]):
         self,
         left: Type,
         right: Type,
-        original_container: Type | None = None,
         *,
+        original_container: Type | None = None,
+        seen_types: set[tuple[Type, Type]] | None = None,
         prefer_literal: bool = True,
     ) -> bool:
         """Check for dangerous non-overlapping comparisons like 42 == 'no'.
@@ -3892,6 +3893,12 @@ class ExpressionChecker(ExpressionVisitor[Type]):
         if not self.chk.options.strict_equality:
             return False
 
+        if seen_types is None:
+            seen_types = set()
+        if (left, right) in seen_types:
+            return False
+        seen_types.add((left, right))
+
         left, right = get_proper_types((left, right))
 
         # We suppress the error if there is a custom __eq__() method on either
@@ -3949,7 +3956,9 @@ class ExpressionChecker(ExpressionVisitor[Type]):
                 abstract_set = self.chk.lookup_typeinfo("typing.AbstractSet")
                 left = map_instance_to_supertype(left, abstract_set)
                 right = map_instance_to_supertype(right, abstract_set)
-                return self.dangerous_comparison(left.args[0], right.args[0])
+                return self.dangerous_comparison(
+                    left.args[0], right.args[0], seen_types=seen_types
+                )
             elif left.type.has_base("typing.Mapping") and right.type.has_base(
                 "typing.Mapping"
             ):
@@ -3958,13 +3967,17 @@ class ExpressionChecker(ExpressionVisitor[Type]):
                 left = map_instance_to_supertype(left, abstract_map)
                 right = map_instance_to_supertype(right, abstract_map)
                 return self.dangerous_comparison(
-                    left.args[0], right.args[0]
-                ) or self.dangerous_comparison(left.args[1], right.args[1])
+                    left.args[0], right.args[0], seen_types=seen_types
+                ) or self.dangerous_comparison(
+                    left.args[1], right.args[1], seen_types=seen_types
+                )
             elif (
                 left_name in ("builtins.list", "builtins.tuple")
                 and right_name == left_name
             ):
-                return self.dangerous_comparison(left.args[0], right.args[0])
+                return self.dangerous_comparison(
+                    left.args[0], right.args[0], seen_types=seen_types
+                )
             elif left_name in OVERLAPPING_BYTES_ALLOWLIST and right_name in (
                 OVERLAPPING_BYTES_ALLOWLIST
             ):
@@ -6624,11 +6637,16 @@ class PolyTranslator(TypeTranslator):
     See docstring for apply_poly() for details.
     """
 
-    def __init__(self, poly_tvars: Sequence[TypeVarLikeType]) -> None:
+    def __init__(
+        self,
+        poly_tvars: Iterable[TypeVarLikeType],
+        bound_tvars: frozenset[TypeVarLikeType] = frozenset(),
+        seen_aliases: frozenset[TypeInfo] = frozenset(),
+    ) -> None:
         self.poly_tvars = set(poly_tvars)
         # This is a simplified version of TypeVarScope used during semantic analysis.
-        self.bound_tvars: set[TypeVarLikeType] = set()
-        self.seen_aliases: set[TypeInfo] = set()
+        self.bound_tvars = bound_tvars
+        self.seen_aliases = seen_aliases
 
     def collect_vars(self, t: CallableType | Parameters) -> list[TypeVarLikeType]:
         found_vars = []
@@ -6706,10 +6724,13 @@ class PolyTranslator(TypeTranslator):
         if t.args and t.type.is_protocol and t.type.protocol_members == ["__call__"]:
             if t.type in self.seen_aliases:
                 raise PolyTranslationError()
-            self.seen_aliases.add(t.type)
             call = find_member("__call__", t, t, is_operator=True)
             assert call is not None
-            return call.accept(self)
+            return call.accept(
+                PolyTranslator(
+                    self.poly_tvars, self.bound_tvars, self.seen_aliases | {t.type}
+                )
+            )
         return super().visit_instance(t)
 
 

jaclang/vendor/mypy/constraints.py

@@ -238,29 +238,29 @@ def infer_constraints_for_callable(
                     callee.arg_names[i],
                     callee.arg_kinds[i],
                 )
-                if (
-                    param_spec
-                    and callee.arg_kinds[i] in (ARG_STAR, ARG_STAR2)
-                    and not incomplete_star_mapping
-                ):
+                if param_spec and callee.arg_kinds[i] in (ARG_STAR, ARG_STAR2):
                     # If actual arguments are mapped to ParamSpec type, we can't infer individual
                     # constraints, instead store them and infer single constraint at the end.
                     # It is impossible to map actual kind to formal kind, so use some heuristic.
                     # This inference is used as a fallback, so relying on heuristic should be OK.
-                    param_spec_arg_types.append(
-                        mapper.expand_actual_type(
-                            actual_arg_type, arg_kinds[actual], None, arg_kinds[actual]
+                    if not incomplete_star_mapping:
+                        param_spec_arg_types.append(
+                            mapper.expand_actual_type(
+                                actual_arg_type,
+                                arg_kinds[actual],
+                                None,
+                                arg_kinds[actual],
+                            )
+                        )
+                        actual_kind = arg_kinds[actual]
+                        param_spec_arg_kinds.append(
+                            ARG_POS
+                            if actual_kind not in (ARG_STAR, ARG_STAR2)
+                            else actual_kind
+                        )
+                        param_spec_arg_names.append(
+                            arg_names[actual] if arg_names else None
                         )
-                    )
-                    actual_kind = arg_kinds[actual]
-                    param_spec_arg_kinds.append(
-                        ARG_POS
-                        if actual_kind not in (ARG_STAR, ARG_STAR2)
-                        else actual_kind
-                    )
-                    param_spec_arg_names.append(
-                        arg_names[actual] if arg_names else None
-                    )
                 else:
                     c = infer_constraints(
                         callee.arg_types[i], actual_type, SUPERTYPE_OF
@@ -285,6 +285,9 @@ def infer_constraints_for_callable(
                 ),
             )
         )
+    if any(isinstance(v, ParamSpecType) for v in callee.variables):
+        # As a perf optimization filter imprecise constraints only when we can have them.
+        constraints = filter_imprecise_kinds(constraints)
     return constraints
 
 
@@ -1197,32 +1200,23 @@ class ConstraintBuilderVisitor(TypeVisitor[List[Constraint]]):
                 )
 
                 param_spec_target: Type | None = None
-                skip_imprecise = (
-                    any(c.type_var == param_spec.id for c in res)
-                    and cactual.imprecise_arg_kinds
-                )
                 if not cactual_ps:
                     max_prefix_len = len(
                         [k for k in cactual.arg_kinds if k in (ARG_POS, ARG_OPT)]
                     )
                     prefix_len = min(prefix_len, max_prefix_len)
-                    # This logic matches top-level callable constraint exception, if we managed
-                    # to get other constraints for ParamSpec, don't infer one with imprecise kinds
-                    if not skip_imprecise:
-                        param_spec_target = Parameters(
-                            arg_types=cactual.arg_types[prefix_len:],
-                            arg_kinds=cactual.arg_kinds[prefix_len:],
-                            arg_names=cactual.arg_names[prefix_len:],
-                            variables=cactual.variables
-                            if not type_state.infer_polymorphic
-                            else [],
-                            imprecise_arg_kinds=cactual.imprecise_arg_kinds,
-                        )
+                    param_spec_target = Parameters(
+                        arg_types=cactual.arg_types[prefix_len:],
+                        arg_kinds=cactual.arg_kinds[prefix_len:],
+                        arg_names=cactual.arg_names[prefix_len:],
+                        variables=cactual.variables
+                        if not type_state.infer_polymorphic
+                        else [],
+                        imprecise_arg_kinds=cactual.imprecise_arg_kinds,
+                    )
                 else:
-                    if (
-                        len(param_spec.prefix.arg_types)
-                        <= len(cactual_ps.prefix.arg_types)
-                        and not skip_imprecise
+                    if len(param_spec.prefix.arg_types) <= len(
+                        cactual_ps.prefix.arg_types
                     ):
                         param_spec_target = cactual_ps.copy_modified(
                             prefix=Parameters(
@@ -1770,3 +1764,27 @@ def infer_callable_arguments_constraints(
                 )
             )
     return res
+
+
+def filter_imprecise_kinds(cs: list[Constraint]) -> list[Constraint]:
+    """For each ParamSpec remove all imprecise constraints, if at least one precise available."""
+    have_precise = set()
+    for c in cs:
+        if not isinstance(c.origin_type_var, ParamSpecType):
+            continue
+        if (
+            isinstance(c.target, ParamSpecType)
+            or isinstance(c.target, Parameters)
+            and not c.target.imprecise_arg_kinds
+        ):
+            have_precise.add(c.type_var)
+    new_cs = []
+    for c in cs:
+        if (
+            not isinstance(c.origin_type_var, ParamSpecType)
+            or c.type_var not in have_precise
+        ):
+            new_cs.append(c)
+        if not isinstance(c.target, Parameters) or not c.target.imprecise_arg_kinds:
+            new_cs.append(c)
+    return new_cs

jaclang/vendor/mypy/expandtype.py

@@ -256,6 +256,7 @@ class ExpandTypeVisitor(TrivialSyntheticTypeTranslator):
                 t.prefix.arg_kinds + repl.arg_kinds,
                 t.prefix.arg_names + repl.arg_names,
                 variables=[*t.prefix.variables, *repl.variables],
+                imprecise_arg_kinds=repl.imprecise_arg_kinds,
             )
         else:
             # We could encode Any as trivial parameters etc., but it would be too verbose.

jaclang/vendor/mypy/meet.py

@@ -268,6 +268,7 @@ def is_overlapping_types(
     ignore_promotions: bool = False,
     prohibit_none_typevar_overlap: bool = False,
     ignore_uninhabited: bool = False,
+    seen_types: set[tuple[Type, Type]] | None = None,
 ) -> bool:
     """Can a value of type 'left' also be of type 'right' or vice-versa?
 
@@ -281,12 +282,19 @@ def is_overlapping_types(
         # A type guard forces the new type even if it doesn't overlap the old.
         return True
 
+    if seen_types is None:
+        seen_types = set()
+    if (left, right) in seen_types:
+        return True
+    if isinstance(left, TypeAliasType) and isinstance(right, TypeAliasType):
+        seen_types.add((left, right))
+
     left, right = get_proper_types((left, right))
 
     def _is_overlapping_types(left: Type, right: Type) -> bool:
         """Encode the kind of overlapping check to perform.
 
-        This function mostly exists so we don't have to repeat keyword arguments everywhere.
+        This function mostly exists, so we don't have to repeat keyword arguments everywhere.
         """
         return is_overlapping_types(
             left,
@@ -294,6 +302,7 @@ def is_overlapping_types(
             ignore_promotions=ignore_promotions,
             prohibit_none_typevar_overlap=prohibit_none_typevar_overlap,
             ignore_uninhabited=ignore_uninhabited,
+            seen_types=seen_types.copy(),
         )
 
     # We should never encounter this type.

jaclang/vendor/mypy/messages.py

@@ -1052,10 +1052,22 @@ class MessageBuilder:
                 context,
             )
 
+    def unexpected_keyword_argument_for_function(
+        self,
+        for_func: str,
+        name: str,
+        context: Context,
+        *,
+        matches: list[str] | None = None,
+    ) -> None:
+        msg = f'Unexpected keyword argument "{name}"' + for_func
+        if matches:
+            msg += f"; did you mean {pretty_seq(matches, 'or')}?"
+        self.fail(msg, context, code=codes.CALL_ARG)
+
     def unexpected_keyword_argument(
         self, callee: CallableType, name: str, arg_type: Type, context: Context
     ) -> None:
-        msg = f'Unexpected keyword argument "{name}"' + for_function(callee)
         # Suggest intended keyword, look for type match else fallback on any match.
         matching_type_args = []
         not_matching_type_args = []
@@ -1069,9 +1081,9 @@ class MessageBuilder:
         matches = best_matches(name, matching_type_args, n=3)
         if not matches:
             matches = best_matches(name, not_matching_type_args, n=3)
-        if matches:
-            msg += f"; did you mean {pretty_seq(matches, 'or')}?"
-        self.fail(msg, context, code=codes.CALL_ARG)
+        self.unexpected_keyword_argument_for_function(
+            for_function(callee), name, context, matches=matches
+        )
         module = find_defining_module(self.modules, callee)
         if module:
             assert callee.definition is not None

jaclang/vendor/mypy/moduleinspect.py

@@ -8,7 +8,7 @@ import os
 import pkgutil
 import queue
 import sys
-from multiprocessing import Process, Queue
+from multiprocessing import Queue, get_context
 from types import ModuleType
 
 
@@ -133,9 +133,15 @@ class ModuleInspect:
         self._start()
 
     def _start(self) -> None:
-        self.tasks: Queue[str] = Queue()
-        self.results: Queue[ModuleProperties | str] = Queue()
-        self.proc = Process(target=worker, args=(self.tasks, self.results, sys.path))
+        if sys.platform == "linux":
+            ctx = get_context("forkserver")
+        else:
+            ctx = get_context("spawn")
+        self.tasks: Queue[str] = ctx.Queue()
+        self.results: Queue[ModuleProperties | str] = ctx.Queue()
+        self.proc = ctx.Process(
+            target=worker, args=(self.tasks, self.results, sys.path)
+        )
         self.proc.start()
         self.counter = 0  # Number of successful roundtrips
 

jaclang/vendor/mypy/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561.  The mypy package uses inline types.

jaclang/vendor/mypy/semanal.py

@@ -811,7 +811,7 @@ class SemanticAnalyzer(
             self.globals = file_node.names
             self.tvar_scope = TypeVarLikeScope()
 
-            self.named_tuple_analyzer = NamedTupleAnalyzer(options, self)
+            self.named_tuple_analyzer = NamedTupleAnalyzer(options, self, self.msg)
             self.typed_dict_analyzer = TypedDictAnalyzer(options, self, self.msg)
             self.enum_call_analyzer = EnumCallAnalyzer(options, self)
             self.newtype_analyzer = NewTypeAnalyzer(options, self, self.msg)
@@ -3035,22 +3035,23 @@ class SemanticAnalyzer(
         if self.check_and_set_up_type_alias(s):
             s.is_alias_def = True
             special_form = True
-        # * type variable definition
-        elif self.process_typevar_declaration(s):
-            special_form = True
-        elif self.process_paramspec_declaration(s):
-            special_form = True
-        elif self.process_typevartuple_declaration(s):
-            special_form = True
-        # * type constructors
-        elif self.analyze_namedtuple_assign(s):
-            special_form = True
-        elif self.analyze_typeddict_assign(s):
-            special_form = True
-        elif self.newtype_analyzer.process_newtype_declaration(s):
-            special_form = True
-        elif self.analyze_enum_assign(s):
-            special_form = True
+        elif isinstance(s.rvalue, CallExpr):
+            # * type variable definition
+            if self.process_typevar_declaration(s):
+                special_form = True
+            elif self.process_paramspec_declaration(s):
+                special_form = True
+            elif self.process_typevartuple_declaration(s):
+                special_form = True
+            # * type constructors
+            elif self.analyze_namedtuple_assign(s):
+                special_form = True
+            elif self.analyze_typeddict_assign(s):
+                special_form = True
+            elif self.newtype_analyzer.process_newtype_declaration(s):
+                special_form = True
+            elif self.analyze_enum_assign(s):
+                special_form = True
 
         if special_form:
             self.record_special_form_lvalue(s)

jaclang/vendor/mypy/semanal_enum.py

@@ -106,16 +106,19 @@ class EnumCallAnalyzer:
         items, values, ok = self.parse_enum_call_args(call, fullname.split(".")[-1])
         if not ok:
             # Error. Construct dummy return value.
-            info = self.build_enum_call_typeinfo(var_name, [], fullname, node.line)
+            name = var_name
+            if is_func_scope:
+                name += "@" + str(call.line)
+            info = self.build_enum_call_typeinfo(name, [], fullname, node.line)
         else:
             name = cast(StrExpr, call.args[0]).value
             if name != var_name or is_func_scope:
                 # Give it a unique name derived from the line number.
                 name += "@" + str(call.line)
             info = self.build_enum_call_typeinfo(name, items, fullname, call.line)
-            # Store generated TypeInfo under both names, see semanal_namedtuple for more details.
-            if name != var_name or is_func_scope:
-                self.api.add_symbol_skip_local(name, info)
+        # Store generated TypeInfo under both names, see semanal_namedtuple for more details.
+        if name != var_name or is_func_scope:
+            self.api.add_symbol_skip_local(name, info)
         call.analyzed = EnumCallExpr(info, items, values)
         call.analyzed.set_line(call)
         info.line = node.line

jaclang/vendor/mypy/semanal_namedtuple.py

@@ -9,6 +9,7 @@ from contextlib import contextmanager
 from typing import Final, Iterator, List, Mapping, cast
 
 from mypy.exprtotype import TypeTranslationError, expr_to_unanalyzed_type
+from mypy.messages import MessageBuilder
 from mypy.nodes import (
     ARG_NAMED_OPT,
     ARG_OPT,
@@ -92,9 +93,12 @@ SELF_TVAR_NAME: Final = "_NT"
 
 
 class NamedTupleAnalyzer:
-    def __init__(self, options: Options, api: SemanticAnalyzerInterface) -> None:
+    def __init__(
+        self, options: Options, api: SemanticAnalyzerInterface, msg: MessageBuilder
+    ) -> None:
         self.options = options
         self.api = api
+        self.msg = msg
 
     def analyze_namedtuple_classdef(
         self, defn: ClassDef, is_stub_file: bool, is_func_scope: bool
@@ -212,6 +216,12 @@ class NamedTupleAnalyzer:
                         )
                 else:
                     default_items[name] = stmt.rvalue
+        if defn.keywords:
+            for_function = ' for "__init_subclass__" of "NamedTuple"'
+            for key in defn.keywords:
+                self.msg.unexpected_keyword_argument_for_function(
+                    for_function, key, defn
+                )
         return items, types, default_items, statements
 
     def check_namedtuple(