eric: comparison src/eric7/Plugins/CheckerPlugins/SyntaxChecker/pyflakes/checker.py

-:bab2f909e60b
+:b2fbf59d889f
 Also, it models the Bindings and Scopes.
 """
 import __future__
 import builtins
 import ast
+import collections
 import contextlib
 import doctest
 import functools
 import os
 import re
 import sys
 import warnings
 from pyflakes import messages
-PY38_PLUS = sys.version_info >= (3, 8)
 PYPY = hasattr(sys, 'pypy_version_info')
 builtin_vars = dir(builtins)
 parse_format_string = string.Formatter().parse
 def getAlternatives(n):
 if isinstance(n, ast.If):
 return [n.body]
-if isinstance(n, ast.Try):
+elif isinstance(n, ast.Try):
 return [n.body + n.orelse] + [[hdl] for hdl in n.handlers]
+elif sys.version_info >= (3, 10) and isinstance(n, ast.Match):
+return [mc.body for mc in n.cases]
 FOR_TYPES = (ast.For, ast.AsyncFor)
-if PY38_PLUS:
 def _is_singleton(node):  # type: (ast.AST) -> bool
 return (
 isinstance(node, ast.Constant) and
 isinstance(node.value, (bool, type(Ellipsis), type(None)))
 )
-else:
-def _is_singleton(node):  # type: (ast.AST) -> bool
-return isinstance(node, (ast.NameConstant, ast.Ellipsis))
 def _is_tuple_constant(node):  # type: (ast.AST) -> bool
 return (
 isinstance(node, ast.Tuple) and
 all(_is_constant(elt) for elt in node.elts)
 )
-if PY38_PLUS:
+def _is_constant(node):
-def _is_constant(node):
+return isinstance(node, ast.Constant) or _is_tuple_constant(node)
-return isinstance(node, ast.Constant) or _is_tuple_constant(node)
-else:
-def _is_constant(node):
-return (
-isinstance(node, (ast.Str, ast.Num, ast.Bytes)) or
-_is_singleton(node) or
-_is_tuple_constant(node)
-)
 def _is_const_non_singleton(node):  # type: (ast.AST) -> bool
 return _is_constant(node) and not _is_singleton(node)
 if isinstance(item, ast.AST):
 yield item
 def convert_to_value(item):
-if isinstance(item, ast.Str):
+if isinstance(item, ast.Constant):
-return item.s
+return item.value
-elif hasattr(ast, 'Bytes') and isinstance(item, ast.Bytes):
-return item.s
 elif isinstance(item, ast.Tuple):
 return tuple(convert_to_value(i) for i in item.elts)
-elif isinstance(item, ast.Num):
-return item.n
 elif isinstance(item, ast.Name):
-result = VariableKey(item=item)
+return VariableKey(item=item)
-constants_lookup = {
-'True': True,
-'False': False,
-'None': None,
-}
-return constants_lookup.get(
-result.name,
-result,
-)
-elif isinstance(item, ast.NameConstant):
-return item.value
 else:
 return UnhandledKeyType()
 def is_notimplemented_name_node(node):
 class Definition(Binding):
 """
 A binding that defines a function or a class.
 """
+def redefines(self, other):
+return (
+super().redefines(other) or
+(isinstance(other, Assignment) and self.name == other.name)
+)
 class Builtin(Definition):
 """A definition created for all Python builtins."""
 else:
 self.names = []
 def _add_to_names(container):
 for node in container.elts:
-if isinstance(node, ast.Str):
+if isinstance(node, ast.Constant) and isinstance(node.value, str):
-self.names.append(node.s)
+self.names.append(node.value)
 if isinstance(source.value, (ast.List, ast.Tuple)):
 _add_to_names(source.value)
 # If concatenating lists or tuples
 elif isinstance(source.value, ast.BinOp):
 for name, binding in self.items():
 if not binding.used and isinstance(binding, Annotation):
 yield name, binding
+class TypeScope(Scope):
+pass
 class GeneratorScope(Scope):
 pass
 class ModuleScope(Scope):
 return func(self, *args, **kwargs)
 return in_annotation_func
 class Checker:
-"""
+"""I check the cleanliness and sanity of Python code."""
-I check the cleanliness and sanity of Python code.
-@ivar _deferredFunctions: Tracking list used by L{deferFunction}.  Elements
-of the list are two-tuples.  The first element is the callable passed
-to L{deferFunction}.  The second element is a copy of the scope stack
-at the time L{deferFunction} was called.
-@ivar _deferredAssignments: Similar to C{_deferredFunctions}, but for
-callables which are deferred assignment checks.
-"""
 _ast_node_scope = {
 ast.Module: ModuleScope,
 ast.ClassDef: ClassScope,
 ast.FunctionDef: FunctionScope,
 }
 nodeDepth = 0
 offset = None
 _in_annotation = AnnotationState.NONE
-_in_deferred = False
 builtIns = set(builtin_vars).union(_MAGIC_GLOBALS)
 _customBuiltIns = os.environ.get('PYFLAKES_BUILTINS')
 if _customBuiltIns:
 builtIns.update(_customBuiltIns.split(','))
 del _customBuiltIns
 def __init__(self, tree, filename='(none)', builtins=None,
 withDoctest='PYFLAKES_DOCTEST' in os.environ, file_tokens=()):
 self._nodeHandlers = {}
-self._deferredFunctions = []
+self._deferred = collections.deque()
-self._deferredAssignments = []
 self.deadScopes = []
 self.messages = []
 self.filename = filename
 if builtins:
 self.builtIns = self.builtIns.union(builtins)
 self.withDoctest = withDoctest
+self.exceptHandlers = [()]
+self.root = tree
+self.scopeStack = []
 try:
-self.scopeStack = [Checker._ast_node_scope[type(tree)]()]
+scope_tp = Checker._ast_node_scope[type(tree)]
 except KeyError:
 raise RuntimeError('No scope implemented for the node %r' % tree)
-self.exceptHandlers = [()]
-self.root = tree
+with self.in_scope(scope_tp):
 for builtin in self.builtIns:
 self.addBinding(None, Builtin(builtin))
 self.handleChildren(tree)
-self._in_deferred = True
+self._run_deferred()
-self.runDeferred(self._deferredFunctions)
-# Set _deferredFunctions to None so that deferFunction will fail
-# noisily if called after we've run through the deferred functions.
-self._deferredFunctions = None
-self.runDeferred(self._deferredAssignments)
-# Set _deferredAssignments to None so that deferAssignment will fail
-# noisily if called after we've run through the deferred assignments.
-self._deferredAssignments = None
-del self.scopeStack[1:]
-self.popScope()
 self.checkDeadScopes()
 if file_tokens:
 warnings.warn(
 '`file_tokens` will be removed in a future version',
 This is used for handling function bodies, which must be deferred
 because code later in the file might modify the global scope. When
 `callable` is called, the scope at the time this is called will be
 restored, however it will contain any new bindings added to it.
 """
-self._deferredFunctions.append((callable, self.scopeStack[:], self.offset))
+self._deferred.append((callable, self.scopeStack[:], self.offset))
-def deferAssignment(self, callable):
+def _run_deferred(self):
-"""
+orig = (self.scopeStack, self.offset)
-Schedule an assignment handler to be called just after deferred
-function handlers.
+while self._deferred:
-"""
+handler, scope, offset = self._deferred.popleft()
-self._deferredAssignments.append((callable, self.scopeStack[:], self.offset))
+self.scopeStack, self.offset = scope, offset
-def runDeferred(self, deferred):
-"""
-Run the callables in C{deferred} using their associated scope stack.
-"""
-for handler, scope, offset in deferred:
-self.scopeStack = scope
-self.offset = offset
 handler()
+self.scopeStack, self.offset = orig
 def _in_doctest(self):
 return (len(self.scopeStack) >= 2 and
 isinstance(self.scopeStack[1], DoctestScope))
 @property
 def scope(self):
 return self.scopeStack[-1]
-def popScope(self):
+@contextlib.contextmanager
-self.deadScopes.append(self.scopeStack.pop())
+def in_scope(self, cls):
+self.scopeStack.append(cls())
+try:
+yield
+finally:
+self.deadScopes.append(self.scopeStack.pop())
 def checkDeadScopes(self):
 """
 Look at scopes which have been fully examined and report names in them
 which were imported but unused.
 """
 for scope in self.deadScopes:
 # imports in classes are public members
 if isinstance(scope, ClassScope):
 continue
+if isinstance(scope, FunctionScope):
+for name, binding in scope.unused_assignments():
+self.report(messages.UnusedVariable, binding.source, name)
+for name, binding in scope.unused_annotations():
+self.report(messages.UnusedAnnotation, binding.source, name)
 all_binding = scope.get('__all__')
 if all_binding and not isinstance(all_binding, ExportBinding):
 all_binding = None
 continue
 else:
 messg = messages.RedefinedWhileUnused
 self.report(messg, node, value.name, value.source)
-def pushScope(self, scopeClass=FunctionScope):
-self.scopeStack.append(scopeClass())
 def report(self, messageClass, *args, **kwargs):
 self.messages.append(messageClass(self.filename, *args, **kwargs))
 def getParent(self, node):
 # Lookup the first parent which is not Tuple, List or Starred
 def handleNodeLoad(self, node, parent):
 name = getNodeName(node)
 if not name:
 return
-in_generators = None
+# only the following can access class scoped variables (since classes
+# aren't really a scope)
+# - direct accesses (not within a nested scope)
+# - generators
+# - type annotations (for generics, etc.)
+can_access_class_vars = None
 importStarred = None
 # try enclosing function scopes and global scope
 for scope in self.scopeStack[-1::-1]:
 if isinstance(scope, ClassScope):
 if name == '__class__':
 return
-elif in_generators is False:
+elif can_access_class_vars is False:
 # only generators used in a class scope can access the
 # names of the class. this is skipped during the first
 # iteration
 continue
 binding = scope.get(name, None)
 if isinstance(binding, Annotation) and not self._in_postponed_annotation:
-scope[name].used = True
+scope[name].used = (self.scope, node)
 continue
 if name == 'print' and isinstance(binding, Builtin):
 if (isinstance(parent, ast.BinOp) and
 isinstance(parent.op, ast.RShift)):
 else:
 return
 importStarred = importStarred or scope.importStarred
-if in_generators is not False:
+if can_access_class_vars is not False:
-in_generators = isinstance(scope, GeneratorScope)
+can_access_class_vars = isinstance(
+scope, (TypeScope, GeneratorScope),
+)
 if importStarred:
 from_list = []
 for scope in self.scopeStack[-1::-1]:
 node._pyflakes_parent,
 (ast.Assign, ast.AugAssign, ast.AnnAssign)
 )
 ):
 binding = ExportBinding(name, node._pyflakes_parent, self.scope)
-elif PY38_PLUS and isinstance(parent_stmt, ast.NamedExpr):
+elif isinstance(parent_stmt, ast.NamedExpr):
 binding = NamedExprAssignment(name, node)
 else:
 binding = Assignment(name, node)
 self.addBinding(node, binding)
 def isDocstring(self, node):
 """
 Determine if the given node is a docstring, as long as it is at the
 correct place in the node tree.
 """
-return isinstance(node, ast.Str) or (isinstance(node, ast.Expr) and
+return (
-isinstance(node.value, ast.Str))
+isinstance(node, ast.Expr) and
+isinstance(node.value, ast.Constant) and
+isinstance(node.value.value, str)
+)
 def getDocstring(self, node):
-if isinstance(node, ast.Expr):
+if (
-node = node.value
+isinstance(node, ast.Expr) and
-if not isinstance(node, ast.Str):
+isinstance(node.value, ast.Constant) and
-return (None, None)
+isinstance(node.value.value, str)
+):
-if PYPY or PY38_PLUS:
+return node.value.value, node.lineno - 1
-doctest_lineno = node.lineno - 1
 else:
-# Computed incorrectly if the docstring has backslash
+return None, None
-doctest_lineno = node.lineno - node.s.count('\n') - 1
-return (node.s, doctest_lineno)
 def handleNode(self, node, parent):
 if node is None:
 return
 if self.offset and getattr(node, 'lineno', None) is not None:
 node.lineno += self.offset[0]
 node.col_offset += self.offset[1]
-if self.futuresAllowed and not (isinstance(node, ast.ImportFrom) or
+if (
-self.isDocstring(node)):
+self.futuresAllowed and
+self.nodeDepth == 0 and
+not isinstance(node, ast.ImportFrom) and
+not self.isDocstring(node)
+):
 self.futuresAllowed = False
 self.nodeDepth += 1
 node._pyflakes_depth = self.nodeDepth
 node._pyflakes_parent = parent
 try:
 # Place doctest in module scope
 saved_stack = self.scopeStack
 self.scopeStack = [self.scopeStack[0]]
 node_offset = self.offset or (0, 0)
-self.pushScope(DoctestScope)
+with self.in_scope(DoctestScope):
 if '_' not in self.scopeStack[0]:
 self.addBinding(None, Builtin('_'))
 for example in examples:
 try:
 tree = ast.parse(example.source, "<doctest>")
 except SyntaxError as e:
 position = (node_lineno + example.lineno + e.lineno,
 example.indent + 4 + (e.offset or 0))
 self.report(messages.DoctestSyntaxError, node, position)
 else:
 self.offset = (node_offset[0] + node_lineno + example.lineno,
 node_offset[1] + example.indent + 4)
 self.handleChildren(tree)
 self.offset = node_offset
-self.popScope()
 self.scopeStack = saved_stack
 @in_string_annotation
 def handleStringAnnotation(self, s, node, ref_lineno, ref_col_offset, err):
 try:
 descendant.lineno = ref_lineno
 descendant.col_offset = ref_col_offset
 self.handleNode(parsed_annotation, node)
+def handle_annotation_always_deferred(self, annotation, parent):
+fn = in_annotation(Checker.handleNode)
+self.deferFunction(lambda: fn(self, annotation, parent))
 @in_annotation
 def handleAnnotation(self, annotation, node):
-if isinstance(annotation, ast.Str):
+if (
+isinstance(annotation, ast.Constant) and
+isinstance(annotation.value, str)
+):
 # Defer handling forward annotation.
 self.deferFunction(functools.partial(
 self.handleStringAnnotation,
-annotation.s,
+annotation.value,
 node,
 annotation.lineno,
 annotation.col_offset,
 messages.ForwardAnnotationSyntaxError,
 ))
 elif self.annotationsFutureEnabled:
-fn = in_annotation(Checker.handleNode)
+self.handle_annotation_always_deferred(annotation, node)
-self.deferFunction(lambda: fn(self, annotation, node))
 else:
 self.handleNode(annotation, node)
 def ignore(self, node):
 pass
 else:
 self.handleChildren(node)
 def _handle_string_dot_format(self, node):
 try:
-placeholders = tuple(parse_format_string(node.func.value.s))
+placeholders = tuple(parse_format_string(node.func.value.value))
 except ValueError as e:
 self.report(messages.StringDotFormatInvalidFormat, node, e)
 return
 auto = None
 )
 def CALL(self, node):
 if (
 isinstance(node.func, ast.Attribute) and
-isinstance(node.func.value, ast.Str) and
+isinstance(node.func.value, ast.Constant) and
+isinstance(node.func.value.value, str) and
 node.func.attr == 'format'
 ):
 self._handle_string_dot_format(node)
 omit = []
 else:
 self.handleChildren(node)
 def _handle_percent_format(self, node):
 try:
-placeholders = parse_percent_format(node.left.s)
+placeholders = parse_percent_format(node.left.value)
 except ValueError:
 self.report(
 messages.PercentFormatInvalidFormat,
 node,
 'incomplete format',
 elif not positional:
 self.report(messages.PercentFormatExpectedMapping, node)
 if (
 isinstance(node.right, ast.Dict) and
-all(isinstance(k, ast.Str) for k in node.right.keys)
+all(
+isinstance(k, ast.Constant) and isinstance(k.value, str)
+for k in node.right.keys
+)
 ):
 if positional and positional_count > 1:
 self.report(messages.PercentFormatExpectedSequence, node)
 return
-substitution_keys = {k.s for k in node.right.keys}
+substitution_keys = {k.value for k in node.right.keys}
 extra_keys = substitution_keys - named
 missing_keys = named - substitution_keys
 if not positional and extra_keys:
 self.report(
 messages.PercentFormatExtraNamedArguments,
 )
 def BINOP(self, node):
 if (
 isinstance(node.op, ast.Mod) and
-isinstance(node.left, ast.Str)
+isinstance(node.left, ast.Constant) and
+isinstance(node.left.value, str)
 ):
 self._handle_percent_format(node)
 self.handleChildren(node)
-def STR(self, node):
+def CONSTANT(self, node):
-if self._in_annotation:
+if isinstance(node.value, str) and self._in_annotation:
 fn = functools.partial(
 self.handleStringAnnotation,
-node.s,
+node.value,
 node,
 node.lineno,
 node.col_offset,
 messages.ForwardAnnotationSyntaxError,
 )
-if self._in_deferred:
+self.deferFunction(fn)
-fn()
-else:
-self.deferFunction(fn)
-if PY38_PLUS:
-def CONSTANT(self, node):
-if isinstance(node.value, str):
-return self.STR(node)
-else:
-NUM = BYTES = ELLIPSIS = CONSTANT = ignore
 # "slice" type nodes
 SLICE = EXTSLICE = INDEX = handleChildren
 # expression contexts are node instances too, though being constants
 scope[node_name] = node_value
 NONLOCAL = GLOBAL
 def GENERATOREXP(self, node):
-self.pushScope(GeneratorScope)
+with self.in_scope(GeneratorScope):
 self.handleChildren(node)
-self.popScope()
 LISTCOMP = DICTCOMP = SETCOMP = GENERATOREXP
 def NAME(self, node):
 """
 # Doesn't apply unless it's in the loop itself
 if n_child not in n.orelse:
 return
 if isinstance(n, (ast.FunctionDef, ast.ClassDef)):
 break
-# Handle Try/TryFinally difference in Python < and >= 3.3
-if hasattr(n, 'finalbody') and isinstance(node, ast.Continue):
-if n_child in n.finalbody and not PY38_PLUS:
-self.report(messages.ContinueInFinally, node)
-return
 if isinstance(node, ast.Continue):
 self.report(messages.ContinueOutsideLoop, node)
 else:  # ast.Break
 self.report(messages.BreakOutsideLoop, node)
 AWAIT = YIELDFROM = YIELD
 def FUNCTIONDEF(self, node):
 for deco in node.decorator_list:
 self.handleNode(deco, node)
-self.LAMBDA(node)
+with self._type_param_scope(node):
+self.LAMBDA(node)
 self.addBinding(node, FunctionDefinition(node.name, node))
 # doctest does not process doctest within a doctest,
 # or in nested functions.
 if (self.withDoctest and
 not self._in_doctest() and
 def LAMBDA(self, node):
 args = []
 annotations = []
-if PY38_PLUS:
+for arg in node.args.posonlyargs:
-for arg in node.args.posonlyargs:
+args.append(arg.arg)
-args.append(arg.arg)
+annotations.append(arg.annotation)
-annotations.append(arg.annotation)
 for arg in node.args.args + node.args.kwonlyargs:
 args.append(arg.arg)
 annotations.append(arg.annotation)
 defaults = node.args.defaults + node.args.kw_defaults
 for default in defaults:
 self.handleNode(default, node)
 def runFunction():
+with self.in_scope(FunctionScope):
-self.pushScope()
+self.handleChildren(
+node,
-self.handleChildren(node, omit=['decorator_list', 'returns'])
+omit=('decorator_list', 'returns', 'type_params'),
+)
-def check_unused_assignments():
-"""
-Check to see if any assignments have not been used.
-"""
-for name, binding in self.scope.unused_assignments():
-self.report(messages.UnusedVariable, binding.source, name)
-def check_unused_annotations():
-"""
-Check to see if any annotations have not been used.
-"""
-for name, binding in self.scope.unused_annotations():
-self.report(messages.UnusedAnnotation, binding.source, name)
-self.deferAssignment(check_unused_assignments)
-self.deferAssignment(check_unused_annotations)
-self.popScope()
 self.deferFunction(runFunction)
 def ARGUMENTS(self, node):
 self.handleChildren(node, omit=('defaults', 'kw_defaults'))
 classes, and the body of its definition.  Additionally, add its name to
 the current scope.
 """
 for deco in node.decorator_list:
 self.handleNode(deco, node)
-for baseNode in node.bases:
-self.handleNode(baseNode, node)
+with self._type_param_scope(node):
-for keywordNode in node.keywords:
+for baseNode in node.bases:
-self.handleNode(keywordNode, node)
+self.handleNode(baseNode, node)
-self.pushScope(ClassScope)
+for keywordNode in node.keywords:
-# doctest does not process doctest within a doctest
+self.handleNode(keywordNode, node)
-# classes within classes are processed.
+with self.in_scope(ClassScope):
-if (self.withDoctest and
+# doctest does not process doctest within a doctest
-not self._in_doctest() and
+# classes within classes are processed.
-not isinstance(self.scope, FunctionScope)):
+if (self.withDoctest and
-self.deferFunction(lambda: self.handleDoctests(node))
+not self._in_doctest() and
-for stmt in node.body:
+not isinstance(self.scope, FunctionScope)):
-self.handleNode(stmt, node)
+self.deferFunction(lambda: self.handleDoctests(node))
-self.popScope()
+for stmt in node.body:
+self.handleNode(stmt, node)
 self.addBinding(node, ClassDefinition(node.name, node))
 def AUGASSIGN(self, node):
 self.handleNodeLoad(node.target, node)
 self.handleNode(node.value, node)
 def _match_target(self, node):
 self.handleNodeStore(node)
 self.handleChildren(node)
 MATCHAS = MATCHMAPPING = MATCHSTAR = _match_target
+@contextlib.contextmanager
+def _type_param_scope(self, node):
+with contextlib.ExitStack() as ctx:
+if sys.version_info >= (3, 12):
+ctx.enter_context(self.in_scope(TypeScope))
+for param in node.type_params:
+self.handleNode(param, node)
+yield
+def TYPEVAR(self, node):
+self.handleNodeStore(node)
+self.handle_annotation_always_deferred(node.bound, node)
+def TYPEALIAS(self, node):
+self.handleNode(node.name, node)
+with self._type_param_scope(node):
+self.handle_annotation_always_deferred(node.value, node)

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Plugins/CheckerPlugins/SyntaxChecker/pyflakes/checker.py

src/eric7/Plugins/CheckerPlugins/SyntaxChecker/pyflakes/checker.py