pyscript-programming-language 1.8.1__tar.gz → 1.9.0__tar.gz

{pyscript_programming_language-1.8.1 → pyscript_programming_language-1.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyscript-programming-language
-Version: 1.8.1
+Version: 1.9.0
 Summary: PyScript Programming Language
 Home-page: https://azzammuhyala.github.io/pyscript
 Author: azzammuhyala

{pyscript_programming_language-1.8.1 → pyscript_programming_language-1.9.0}/pyscript/__init__.py

@@ -1,5 +1,5 @@
 """
-PyScript is a programming language written in Python. \
+PyScript is a programming language written 100% in Python. \
 This language is not isolated and is directly integrated with the Python's library and namespace levels.
 """
 
@@ -8,18 +8,18 @@ if __import__('sys').version_info < (3, 10):
 
 from . import core
 
-from .core.constants import DEFAULT, DEBUG, SILENT, RETRES, HIGHLIGHT, NO_COLOR, REVERSE_POW_XOR
-from .core.cache import undefined
+from .core.constants import DEFAULT, DEBUG, SILENT, RETURN_RESULT, HIGHLIGHT, NO_COLOR, REVERSE_POW_XOR
+from .core.cache import undefined, hook
 from .core.highlight import HLFMT_HTML, HLFMT_ANSI, HLFMT_BBCODE, pys_highlight, PygmentsPyScriptLexer
 from .core.runner import pys_exec, pys_eval, pys_require, pys_shell
-from .core.version import version_info, __version__, __date__
+from .core.version import version, version_info, __version__, __date__
 
 __all__ = (
     'core',
     'DEFAULT',
     'DEBUG',
     'SILENT',
-    'RETRES',
+    'RETURN_RESULT',
     'HIGHLIGHT',
     'NO_COLOR',
     'REVERSE_POW_XOR',
@@ -27,6 +27,8 @@ __all__ = (
     'HLFMT_ANSI',
     'HLFMT_BBCODE',
     'undefined',
+    'hook',
+    'version',
     'version_info',
     'pys_highlight',
     'pys_exec',

{pyscript_programming_language-1.8.1 → pyscript_programming_language-1.9.0}/pyscript/__init__.pyi

@@ -1,8 +1,8 @@
-from typing import TYPE_CHECKING, Any, Callable, Iterator, Literal, Optional
+from typing import TYPE_CHECKING, Any, Callable, Iterable, Literal, Optional
 
 if TYPE_CHECKING:
     from .core.buffer import PysFileBuffer
-    from .core.cache import PysUndefined
+    from .core.cache import PysUndefined, PysHook
     from .core.highlight import _PysHighlightFormatter
     from .core.position import PysPosition
     from .core.results import PysExecuteResult
@@ -10,7 +10,7 @@ if TYPE_CHECKING:
     from .core.version import PysVersionInfo
 
     from io import IOBase
-    from types import ModuleType
+    from types import BuiltinMethodType, ModuleType
 
 from . import core as core
 from .core.highlight import PygmentsPyScriptLexer as PygmentsPyScriptLexer
@@ -18,7 +18,7 @@ from .core.highlight import PygmentsPyScriptLexer as PygmentsPyScriptLexer
 DEFAULT: int
 DEBUG: int
 SILENT: int
-RETRES: int
+RETURN_RESULT: int
 HIGHLIGHT: int
 NO_COLOR: int
 REVERSE_POW_XOR: int
@@ -28,10 +28,12 @@ HLFMT_ANSI: _PysHighlightFormatter
 HLFMT_BBCODE: _PysHighlightFormatter
 
 undefined: PysUndefined
+hook: PysHook
+version: str
 version_info: PysVersionInfo
 
 def pys_highlight(
-    source: str | bytes | bytearray | Iterator | Callable | IOBase | PysFileBuffer,
+    source: str | bytes | bytearray | Iterable | BuiltinMethodType | IOBase | PysFileBuffer,
     format: Optional[
         Callable[
             [
@@ -49,13 +51,13 @@ def pys_highlight(
 ) -> str: ...
 
 def pys_exec(
-    source: str | bytes | bytearray | Iterator | Callable | IOBase | PysFileBuffer,
+    source: str | bytes | bytearray | Iterable | BuiltinMethodType | IOBase | PysFileBuffer,
     globals: Optional[dict[str, Any] | PysSymbolTable | PysUndefined] = None,
     flags: int = DEFAULT
 ) -> None | PysExecuteResult: ...
 
 def pys_eval(
-    source: str | bytes | bytearray | Iterator | Callable | IOBase | PysFileBuffer,
+    source: str | bytes | bytearray | Iterable | BuiltinMethodType | IOBase | PysFileBuffer,
     globals: Optional[dict[str, Any] | PysSymbolTable | PysUndefined] = None,
     flags: int = DEFAULT
 ) -> Any | PysExecuteResult: ...

{pyscript_programming_language-1.8.1 → pyscript_programming_language-1.9.0}/pyscript/core/__init__.py

@@ -1,5 +1,5 @@
 """
-PyScript implementations.
+The Core of PyScript Implementations.
 """
 
 from . import (

{pyscript_programming_language-1.8.1 → pyscript_programming_language-1.9.0}/pyscript/core/analyzer.py

@@ -1,6 +1,6 @@
 from .bases import Pys
-from .checks import is_assign, is_incremental
-from .constants import TOKENS, DEFAULT
+from .checks import is_unpack_assignment, is_incremental
+from .constants import TOKENS, KEYWORDS, DEFAULT
 from .context import PysContext
 from .exceptions import PysTraceback
 from .nodes import PysNode, PysKeywordNode, PysIdentifierNode, PysAttributeNode, PysSubscriptNode
@@ -42,9 +42,10 @@ class PysAnalyzer(Pys):
     def analyze(self) -> PysTraceback | None:
         self.in_loop = 0
         self.in_function = 0
+        self.in_class = 0
         self.in_switch = 0
-        self.error = None
         self.parameters = set()
+        self.error = None
 
         self.visit(self.node)
         return self.error
@@ -357,15 +358,23 @@ class PysAnalyzer(Pys):
         self.in_function = 0
         self.in_switch = 0
 
+        self.in_class += 1
+
         self.visit(node.body)
         if self.error:
             return
 
+        self.in_class -= 1
+
         self.in_loop = in_loop
         self.in_function = in_function
         self.in_switch = in_switch
 
     def visit_FunctionNode(self, node):
+        if node.constructor and self.in_class == 0:
+            self.throw(f"{KEYWORDS['constructor']} function outside of class", node.name.position)
+            return
+
         for decorator in node.decorators:
             self.visit(decorator)
             if self.error:
@@ -387,9 +396,10 @@ class PysAnalyzer(Pys):
                 if self.error:
                     return
 
-        in_loop, in_switch, parameters = self.in_loop, self.in_switch, self.parameters
+        in_loop, in_class, in_switch, parameters = self.in_loop, self.in_class, self.in_switch, self.parameters
 
         self.in_loop = 0
+        self.in_class = 0
         self.in_switch = 0
 
         self.in_function += 1
@@ -403,20 +413,21 @@ class PysAnalyzer(Pys):
         self.parameters = parameters
 
         self.in_loop = in_loop
+        self.in_class = in_class
         self.in_switch = in_switch
 
     def visit_GlobalNode(self, node):
         if self.in_function == 0:
-            self.throw("global outside of function", node.position)
+            self.throw(f"{KEYWORDS['global']} outside of function", node.position)
 
         for identifier in node.identifiers:
             if identifier.value in self.parameters:
-                self.throw("name {!r} is parameter and global".format(identifier.value), identifier.position)
+                self.throw(f"name {identifier.value!r} is parameter and global", identifier.position)
                 return
 
     def visit_ReturnNode(self, node):
         if self.in_function == 0:
-            self.throw("return outside of function", node.position)
+            self.throw(f"{KEYWORDS['return']} outside of function", node.position)
             return
 
         if node.value:
@@ -457,12 +468,12 @@ class PysAnalyzer(Pys):
                     return
 
             elif type is PysKeywordNode:
-                self.throw(f"cannot delete {target.name.value}", target.position)
+                self.throw(f"cannot {KEYWORDS['delete']} {target.name.value}", target.position)
                 return
 
             elif isinstance(target, PysNode):
                 if type is not PysIdentifierNode:
-                    self.throw("cannot delete literal", target.position)
+                    self.throw(f"cannot {KEYWORDS['delete']} literal", target.position)
                     return
 
             else:
@@ -470,11 +481,11 @@ class PysAnalyzer(Pys):
 
     def visit_ContinueNode(self, node):
         if self.in_loop == 0:
-            self.throw("continue outside of loop", node.position)
+            self.throw(f"{KEYWORDS['continue']} outside of loop", node.position)
 
     def visit_BreakNode(self, node):
         if self.in_loop == 0 and self.in_switch == 0:
-            self.throw("break outside of loop or switch case", node.position)
+            self.throw(f"{KEYWORDS['break']} outside of loop or switch case", node.position)
 
     def visit_slice_SubscriptNode(self, nslice):
         type = nslice.__class__
@@ -517,7 +528,7 @@ class PysAnalyzer(Pys):
 
             self.visit_slice_SubscriptNode(node.slice)
 
-        elif is_assign(type):
+        elif is_unpack_assignment(type):
             for element in node.elements:
                 self.visit_declaration_AssignNode(element, message)
                 if self.error:

{pyscript_programming_language-1.8.1 → pyscript_programming_language-1.9.0}/pyscript/core/buffer.py

@@ -4,6 +4,7 @@ from .utils.generic import setimuattr
 from .utils.string import normstr
 
 from io import IOBase
+from typing import Callable, Iterable, Optional
 
 @immutable
 class PysBuffer(Pys):
@@ -13,7 +14,11 @@ class PysFileBuffer(PysBuffer):
 
     __slots__ = ('text', 'name')
 
-    def __init__(self, text, name=None) -> None:
+    def __init__(
+        self,
+        text: str | bytes | bytearray | Iterable | Callable | IOBase | 'PysFileBuffer',
+        name: Optional[str | bytes] = None
+    ) -> None:
 
         if isinstance(text, PysFileBuffer):
             name = normstr(text.name if name is None else name)

{pyscript_programming_language-1.8.1 → pyscript_programming_language-1.9.0}/pyscript/core/cache.py

@@ -1,10 +1,11 @@
 from .bases import Pys
 from .constants import LIBRARIES_PATH, SITE_PACKAGES_PATH
+from .exceptions import PysTraceback
 from .utils.debug import print_display, print_traceback
 from .utils.decorators import inheritable, singleton
 
 from threading import RLock
-from typing import Literal
+from typing import Any, Callable, Literal
 
 loading_modules = set()
 lock = RLock()
@@ -35,7 +36,7 @@ class PysHook(Pys):
 
     __slots__ = ()
 
-    def __new_singleton__(cls):
+    def __new_singleton__(cls) -> 'PysHook':
         global hook
         hook = super(cls, cls).__new__(cls)
         hook.running_shell = False
@@ -46,61 +47,61 @@ class PysHook(Pys):
         hook.ps2 = '... '
         return hook
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f'<hook object at {id(self):016X}>'
 
     @property
-    def running_shell(self):
+    def running_shell(self) -> bool:
         return singletons['hook.running_shell']
 
     @running_shell.setter
-    def running_shell(self, value):
+    def running_shell(self, value: bool) -> None:
         singletons['hook.running_shell'] = bool(value)
 
     @property
-    def running_breakpoint(self):
+    def running_breakpoint(self) -> bool:
         return singletons['hook.running_breakpoint']
 
     @running_breakpoint.setter
-    def running_breakpoint(self, value):
+    def running_breakpoint(self, value: bool) -> None:
         singletons['hook.running_breakpoint'] = bool(value)
 
     @property
-    def display(self):
+    def display(self) -> Callable[[Any], None]:
         return singletons['hook.display']
 
     @display.setter
-    def display(self, value):
+    def display(self, value: Callable[[Any], None]) -> None:
         if value is not None and not callable(value):
             raise TypeError("hook.display: must be callable")
         singletons['hook.display'] = value
 
     @property
-    def exception(self):
+    def exception(self) -> Callable[[type[BaseException], BaseException | None, PysTraceback], None]:
         return singletons['hook.exception']
 
     @exception.setter
-    def exception(self, value):
+    def exception(self, value: Callable[[type[BaseException], BaseException | None, PysTraceback], None]) -> None:
         if value is not None and not callable(value):
             raise TypeError("hook.exception: must be callable")
         singletons['hook.exception'] = value
 
     @property
-    def ps1(self):
+    def ps1(self) -> str:
         return singletons['hook.ps1']
 
     @ps1.setter
-    def ps1(self, value):
+    def ps1(self, value: str) -> None:
         if not isinstance(value, str):
             raise TypeError("hook.ps1: must be a string")
         singletons['hook.ps1'] = value
 
     @property
-    def ps2(self):
+    def ps2(self) -> str:
         return singletons['hook.ps2']
 
     @ps2.setter
-    def ps2(self, value):
+    def ps2(self, value: str) -> None:
         if not isinstance(value, str):
             raise TypeError("hook.ps2: must be a string")
         singletons['hook.ps2'] = value

{pyscript_programming_language-1.8.1 → pyscript_programming_language-1.9.0}/pyscript/core/checks.py

@@ -14,7 +14,7 @@ is_statement = frozenset([
     PysDeleteNode, PysContinueNode, PysBreakNode
 ]).__contains__
 
-is_assign = frozenset([
+is_unpack_assignment = frozenset([
     PysSetNode, PysListNode, PysTupleNode
 ]).__contains__
 

{pyscript_programming_language-1.8.1 → pyscript_programming_language-1.9.0}/pyscript/core/constants.py

@@ -102,6 +102,7 @@ KEYWORDS = MappingProxyType({
     'case': 'case',
     'catch': 'catch',
     'class': 'class',
+    'constructor': 'constructor',
     'continue': 'continue',
     'default': 'default',
     'del': 'del',
@@ -137,15 +138,16 @@ KEYWORDS = MappingProxyType({
 
 CONSTANT_KEYWORDS = (
     KEYWORDS['__debug__'], KEYWORDS['False'], KEYWORDS['None'], KEYWORDS['True'], KEYWORDS['and'], KEYWORDS['class'],
-    KEYWORDS['extends'], KEYWORDS['func'], KEYWORDS['function'], KEYWORDS['false'], KEYWORDS['global'], KEYWORDS['in'],
-    KEYWORDS['is'], KEYWORDS['not'], KEYWORDS['none'], KEYWORDS['of'], KEYWORDS['or'], KEYWORDS['true']
+    KEYWORDS['constructor'], KEYWORDS['extends'], KEYWORDS['func'], KEYWORDS['function'], KEYWORDS['false'],
+    KEYWORDS['global'], KEYWORDS['in'], KEYWORDS['is'], KEYWORDS['not'], KEYWORDS['none'], KEYWORDS['of'],
+    KEYWORDS['or'], KEYWORDS['true']
 )
 
 # flags
 DEFAULT = 0
 DEBUG = 1 << 0
 SILENT = 1 << 1
-RETRES = 1 << 2
+RETURN_RESULT = 1 << 2
 HIGHLIGHT = 1 << 3
 NO_COLOR = 1 << 4
 REVERSE_POW_XOR = 1 << 5

{pyscript_programming_language-1.8.1 → pyscript_programming_language-1.9.0}/pyscript/core/context.py

@@ -1,8 +1,13 @@
 from .bases import Pys
+from .buffer import PysFileBuffer
 from .constants import DEFAULT
+from .position import PysPosition
+from .symtab import PysSymbolTable
 from .utils.decorators import immutable
 from .utils.generic import setimuattr
 
+from typing import Optional
+
 @immutable
 class PysContext(Pys):
 
@@ -10,14 +15,15 @@ class PysContext(Pys):
 
     def __init__(
         self,
-        file,
-        name=None,
-        qualname=None,
-        flags=None,
-        symbol_table=None,
-        parent=None,
-        parent_entry_position=None
-    ):
+        *,
+        file: PysFileBuffer,
+        name: Optional[str] = None,
+        qualname: Optional[str] = None,
+        flags: Optional[int] = None,
+        symbol_table: Optional[PysSymbolTable] = None,
+        parent: Optional['PysContext'] = None,
+        parent_entry_position: Optional[PysPosition] = None
+    ) -> None:
         if flags is None and parent:
             flags = parent.flags
 
@@ -29,7 +35,7 @@ class PysContext(Pys):
         setimuattr(self, 'parent', parent)
         setimuattr(self, 'parent_entry_position', parent_entry_position)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f'<Context {self.name!r}>'
 
 class PysClassContext(PysContext):
@@ -38,11 +44,12 @@ class PysClassContext(PysContext):
 
     def __init__(
         self,
-        name,
-        symbol_table,
-        parent,
-        parent_entry_position
-    ):
+        *,
+        name: str,
+        symbol_table: PysSymbolTable,
+        parent: PysContext,
+        parent_entry_position: PysPosition
+    ) -> None:
         qualname = parent.qualname
         super().__init__(
             file=parent.file,

{pyscript_programming_language-1.8.1 → pyscript_programming_language-1.9.0}/pyscript/core/exceptions.py

@@ -5,22 +5,37 @@ from .utils.decorators import immutable
 from .utils.generic import setimuattr
 from .utils.string import indent
 
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from .context import PysContext
+    from .position import PysPosition
+    from .results import PysRunTimeResult
+
 @immutable
 class PysTraceback(Pys):
 
     __slots__ = ('exception', 'context', 'position', 'cause', 'directly')
 
-    def __init__(self, exception, context, position, cause=None, directly=False):
+    def __init__(
+        self,
+        exception: BaseException | type[BaseException],
+        context: 'PysContext',
+        position: 'PysPosition',
+        cause: Optional['PysTraceback'] = None,
+        directly: bool = False
+    ) -> None:
+
         setimuattr(self, 'exception', exception)
         setimuattr(self, 'context', context)
         setimuattr(self, 'position', position)
         setimuattr(self, 'cause', cause)
         setimuattr(self, 'directly', directly)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f'<traceback of exception {self.exception!r}>'
 
-    def string_traceback(self):
+    def string_traceback(self) -> str:
         from .position import format_arrow  # circular import problem solved
 
         context = self.context
@@ -95,11 +110,11 @@ class PysSignal(Pys, BaseException):
 
     __slots__ = ('result',)
 
-    def __init__(self, result):
+    def __init__(self, result: 'PysRunTimeResult') -> None:
         super().__init__()
         self.result = result
 
-    def __str__(self):
+    def __str__(self) -> str:
         if self.result.error is None:
             return '<signal>'
 

{pyscript_programming_language-1.8.1 → pyscript_programming_language-1.9.0}/pyscript/core/highlight.py

@@ -43,9 +43,9 @@ _builtin_functions = tuple(
 )
 
 try:
-    # if pygments module exists
+    # if pygments module already exists
     from pygments.lexer import RegexLexer, include, bygroups
-    from pygments.token import Comment, Keyword, Name, Number, String, Text
+    from pygments.token import Comment, Keyword, Name, Number, Punctuation, String, Whitespace
     from pygments.unistring import xid_start, xid_continue
 
     _keyword_definitions = (KEYWORDS['class'], KEYWORDS['func'], KEYWORDS['function'])
@@ -66,6 +66,12 @@ try:
         tokens = {
 
             'root': [
+                # Whitespaces
+                (r'\s+', Whitespace),
+
+                # Punctuation
+                (r'[!%&\(\)\*\+,\-\./:;<=>\?@\[\]^{\|}~\\]+', Punctuation),
+
                 # Keywords
                 (
                     r'\b(' + '|'.join(filter(lambda k: not is_constant_keywords(k), KEYWORDS)) + r')\b',
@@ -121,11 +127,11 @@ try:
                 # Numbers
                 (
                     r'0[bB][01](_?[01])*[jJiI]?',
-                    Number.Binary
+                    Number.Bin
                 ),
                 (
                     r'0[oO][0-7](_?[0-7])*[jJiI]?',
-                    Number.Octal
+                    Number.Oct
                 ),
                 (
                     r'0[xX][0-9a-fA-F](_?[0-9a-fA-F])*[jJiI]?',
@@ -142,20 +148,24 @@ try:
                 ),
 
                 # Comments
-                (r'#.*$', Comment.Single),
+                (
+                    r'#',
+                    Comment.Single,
+                    'in-comment'
+                ),
 
                 # Class definition
                 (
                     r'\b(' + KEYWORDS['class'] + r')\b'
                     r'(\s*)((?:\$(?:[^\S\r\n]*))?\b' + _unicode_name + r'*)\b',
-                    bygroups(Keyword.Declaration, Text, Name.Class)
+                    bygroups(Keyword.Constant, Whitespace, Name.Class)
                 ),
 
                 # Function definition
                 (
                     r'\b(' + KEYWORDS['func'] + '|' + KEYWORDS['function'] + r')\b' +
                     r'(\s*)((?:\$(?:[^\S\r\n]*))?\b' + _unicode_name + r'*)\b',
-                    bygroups(Keyword.Declaration, Text, Name.Function)
+                    bygroups(Keyword.Constant, Whitespace, Name.Function)
                 ),
 
                 # Keywords (if that definition is unmatched)
@@ -184,13 +194,17 @@ try:
                 (r'(?:\$(?:[^\S\r\n]*))?\b' + _unicode_name + r'*\b', Name),
             ],
 
+            'todo-keywords': [
+                (r'\b(TODO|NOTE|FIXME|BUG|HACK)\b', Keyword.Constant.Todo)
+            ],
+
             'string-escapes': [
                 (r'\\([nrtbfav\'"\n\r])', String.Escape),
                 (r'\\[0-7]{1,3}}', String.Escape.Octal),
                 (r'\\x[0-9A-Fa-f]{2}', String.Escape.Hex),
                 (r'\\u[0-9A-Fa-f]{4}', String.Escape.Unicode),
                 (r'\\U[0-9A-Fa-f]{8}', String.Escape.Unicode),
-                (r'\\N\{[^}]+\}', String.Escape.Unicode),
+                (r'\\N\{[^}]+\}', String.Escape.UnicodeName),
                 (r'\\.', String.Escape.Invalid)
             ],
 
@@ -214,12 +228,14 @@ try:
             'string-apostrophe-triple': [
                 (r"'''", String.Delimiter, '#pop'),
                 include('string-escapes'),
+                include('todo-keywords'),
                 (r'.', String)
             ],
 
             'string-quotation-triple': [
                 (r'"""', String.Delimiter, '#pop'),
                 include('string-escapes'),
+                include('todo-keywords'),
                 (r'.', String)
             ],
 
@@ -238,23 +254,31 @@ try:
             'string-apostrophe-single': [
                 (r"'", String.Delimiter, '#pop'),
                 include('string-escapes'),
+                include('todo-keywords'),
                 (r'.', String)
             ],
 
             'string-quotation-single': [
                 (r'"', String.Delimiter, '#pop'),
                 include('string-escapes'),
+                include('todo-keywords'),
                 (r'.', String)
             ],
 
+            'in-comment': [
+                (r'$', Comment.Single, '#pop'),
+                include('todo-keywords'),
+                (r'.', Comment.Single),
+            ]
+
         }
 
-except ImportError:
+except ImportError as e:
 
     class PygmentsPyScriptLexer(Pys):
 
         def __new__(cls, *args, **kwargs):
-            raise ModuleNotFoundError("module pygments is not found")
+            raise ModuleNotFoundError(f"cannot import module pygments: {e}")
 
 @typechecked
 class _PysHighlightFormatter(Pys):

{pyscript_programming_language-1.8.1 → pyscript_programming_language-1.9.0}/pyscript/core/interpreter.py

@@ -1,6 +1,6 @@
 from .constants import TOKENS, KEYWORDS, DEBUG
 from .cache import undefined
-from .checks import is_assign, is_equals, is_incremental, is_public_attribute
+from .checks import is_unpack_assignment, is_equals, is_incremental, is_public_attribute
 from .context import PysClassContext
 from .exceptions import PysTraceback
 from .handlers import handle_call
@@ -477,8 +477,7 @@ def visit_ImportNode(node, context):
                     return result.failure(
                         PysTraceback(
                             TypeError(
-                                f"Item in {module.__name__}.{exported_from} must be str, "
-                                f"not {type(package).__name__}"
+                                f"Item in {module.__name__}.{exported_from} must be str, not {type(package).__name__}"
                             ),
                             context,
                             name_position
@@ -1397,7 +1396,7 @@ def visit_declaration_AssignNode(node, context, value, operand=TOKENS['EQUAL']):
         if should_return():
             return result
 
-    elif is_assign(ntype):
+    elif is_unpack_assignment(ntype):
         position = node.position
 
         if not isinstance(value, Iterable):