eric: comparison eric6/Plugins/CheckerPlugins/SyntaxChecker/pyflakes/checker.py

-:fb0ef164f536
+:698ae46f40a4
 else:
 FOR_TYPES = (ast.For,)
 LOOP_TYPES = (ast.While, ast.For)
 FUNCTION_TYPES = (ast.FunctionDef,)
+if PY36_PLUS:
+ANNASSIGN_TYPES = (ast.AnnAssign,)
+else:
+ANNASSIGN_TYPES = ()
 if PY38_PLUS:
 def _is_singleton(node):  # type: (ast.AST) -> bool
 return (
 isinstance(node, ast.Constant) and
 )
 def _is_const_non_singleton(node):  # type: (ast.AST) -> bool
 return _is_constant(node) and not _is_singleton(node)
+def _is_name_or_attr(node, name):  # type: (ast.Ast, str) -> bool
+return (
+(isinstance(node, ast.Name) and node.id == name) or
+(isinstance(node, ast.Attribute) and node.attr == name)
+)
 # https://github.com/python/typed_ast/blob/1.4.0/ast27/Parser/tokenizer.c#L102-L104
 TYPE_COMMENT_RE = re.compile(r'^#\s*type:\s*')
 # https://github.com/python/typed_ast/blob/1.4.0/ast27/Parser/tokenizer.c#L1408-L1413
 class Builtin(Definition):
 """A definition created for all Python builtins."""
 def __init__(self, name):
-super(Builtin, self).__init__(name, None)
+super().__init__(name, None)
 def __repr__(self):
 return '<%s object %r at 0x%x>' % (self.__class__.__name__,
 self.name,
 id(self))
 """
 def __init__(self, name, source, full_name=None):
 self.fullName = full_name or name
 self.redefined = []
-super(Importation, self).__init__(name, source)
+super().__init__(name, source)
 def redefines(self, other):
 if isinstance(other, SubmoduleImportation):
 # See note in SubmoduleImportation about RedefinedWhileUnused
 return self.fullName == other.fullName
 def __init__(self, name, source):
 # A dot should only appear in the name when it is a submodule import
 assert '.' in name and (not source or isinstance(source, ast.Import))
 package_name = name.split('.')[0]
-super(SubmoduleImportation, self).__init__(package_name, source)
+super().__init__(package_name, source)
 self.fullName = name
 def redefines(self, other):
 if isinstance(other, Importation):
 return self.fullName == other.fullName
-return super(SubmoduleImportation, self).redefines(other)
+return super().redefines(other)
 def __str__(self):
 return self.fullName
 @property
 if module.endswith('.'):
 full_name = module + self.real_name
 else:
 full_name = module + '.' + self.real_name
-super(ImportationFrom, self).__init__(name, source, full_name)
+super().__init__(name, source, full_name)
 def __str__(self):
 """Return import full name with alias."""
 if self.real_name != self.name:
 return self.fullName + ' as ' + self.name
 class StarImportation(Importation):
 """A binding created by a 'from x import *' statement."""
 def __init__(self, name, source):
-super(StarImportation, self).__init__('*', source)
+super().__init__('*', source)
 # Each star importation needs a unique name, and
 # may not be the module name otherwise it will be deemed imported
 self.name = name + '.*'
 self.fullName = name
 `__future__` imports are implicitly used.
 """
 def __init__(self, name, source, scope):
-super(FutureImportation, self).__init__(name, source, '__future__')
+super().__init__(name, source, '__future__')
 self.used = (scope, source)
 class Argument(Binding):
 """
 the checker does not consider assignments in tuple/list unpacking to be
 Assignments, rather it treats them as simple Bindings.
 """
+class Annotation(Binding):
+"""
+Represents binding a name to a type without an associated value.
+As long as this name is not assigned a value in another binding, it is considered
+undefined for most purposes. One notable exception is using the name as a type
+annotation.
+"""
+def redefines(self, other):
+"""An Annotation doesn't define any name, so it cannot redefine one."""
+return False
 class FunctionDefinition(Definition):
 pass
 class ClassDefinition(Definition):
 """
 A binding created by an C{__all__} assignment.  If the names in the list
 can be determined statically, they will be treated as names for export and
 additional checking applied to them.
-The only recognized C{__all__} assignment via list concatenation is in the
+The only recognized C{__all__} assignment via list/tuple concatenation is in the
 following format:
 __all__ = ['a'] + ['b'] + ['c']
 Names which are imported and not otherwise used but appear in the value of
 if isinstance(node, ast.Str):
 self.names.append(node.s)
 if isinstance(source.value, (ast.List, ast.Tuple)):
 _add_to_names(source.value)
-# If concatenating lists
+# If concatenating lists or tuples
 elif isinstance(source.value, ast.BinOp):
 currentValue = source.value
-while isinstance(currentValue.right, ast.List):
+while isinstance(currentValue.right, (ast.List, ast.Tuple)):
 left = currentValue.left
 right = currentValue.right
 _add_to_names(right)
 # If more lists are being added
 if isinstance(left, ast.BinOp):
 currentValue = left
 # If just two lists are being added
-elif isinstance(left, ast.List):
+elif isinstance(left, (ast.List, ast.Tuple)):
 _add_to_names(left)
 # All lists accounted for - done
 break
 # If not list concatenation
 else:
 break
-super(ExportBinding, self).__init__(name, source)
+super().__init__(name, source)
 class Scope(dict):
 importStarred = False       # set to True when import * is found
 usesLocals = False
 alwaysUsed = {'__tracebackhide__', '__traceback_info__',
 '__traceback_supplement__'}
 def __init__(self):
-super(FunctionScope, self).__init__()
+super().__init__()
 # Simplify: manage the special locals as globals
 self.globals = self.alwaysUsed.copy()
 self.returnValue = None     # First non-empty return
 self.isGenerator = False    # Detect a generator
 def __init__(self, lineno, col_offset):
 self.lineno = lineno
 self.col_offset = col_offset
+class DetectClassScopedMagic:
+names = dir()
 # Globally defined names which are not attributes of the builtins module, or
 # are only present on some platforms.
 _MAGIC_GLOBALS = ['__file__', '__builtins__', 'WindowsError']
 # module scope annotation will store in `__annotations__`, see also PEP 526.
 if PY36_PLUS:
 for dec in value.source.decorator_list
 )
 )
+class AnnotationState:
+NONE = 0
+STRING = 1
+BARE = 2
 def in_annotation(func):
 @functools.wraps(func)
 def in_annotation_func(self, *args, **kwargs):
 with self._enter_annotation():
+return func(self, *args, **kwargs)
+return in_annotation_func
+def in_string_annotation(func):
+@functools.wraps(func)
+def in_annotation_func(self, *args, **kwargs):
+with self._enter_annotation(AnnotationState.STRING):
 return func(self, *args, **kwargs)
 return in_annotation_func
 def make_tokens(code):
 _ast_node_scope[ast.AsyncFunctionDef] = FunctionScope
 nodeDepth = 0
 offset = None
 traceTree = False
-_in_annotation = False
+_in_annotation = AnnotationState.NONE
-_in_typing_literal = False
 _in_deferred = False
 builtIns = set(builtin_vars).union(_MAGIC_GLOBALS)
 _customBuiltIns = os.environ.get('PYFLAKES_BUILTINS')
 if _customBuiltIns:
 if all_binding and not isinstance(all_binding, ExportBinding):
 all_binding = None
 if all_binding:
 all_names = set(all_binding.names)
-undefined = all_names.difference(scope)
+undefined = [
+name for name in all_binding.names
+if name not in scope
+]
 else:
 all_names = undefined = []
 if undefined:
 if not scope.importStarred and \
 if value.name in self.scope:
 # then assume the rebound name is used as a global or within a loop
 value.used = self.scope[value.name].used
-self.scope[value.name] = value
+# don't treat annotations as assignments if there is an existing value
+# in scope
+if value.name not in self.scope or not isinstance(value, Annotation):
+self.scope[value.name] = value
 def _unknown_handler(self, node):
 # this environment variable configures whether to error on unknown
 # ast types.
 #
 # only generators used in a class scope can access the
 # names of the class. this is skipped during the first
 # iteration
 continue
-if (name == 'print' and
+binding = scope.get(name, None)
-isinstance(scope.get(name, None), Builtin)):
+if isinstance(binding, Annotation) and not self._in_postponed_annotation:
+continue
+if name == 'print' and isinstance(binding, Builtin):
 parent = self.getParent(node)
 if (isinstance(parent, ast.BinOp) and
 isinstance(parent.op, ast.RShift)):
 self.report(messages.InvalidPrintSyntax, node)
 if name == '__path__' and os.path.basename(self.filename) == '__init__.py':
 # the special name __path__ is valid only in packages
 return
-if name == '__module__' and isinstance(self.scope, ClassScope):
+if name in DetectClassScopedMagic.names and isinstance(self.scope, ClassScope):
 return
 # protected with a NameError handler?
 if 'NameError' not in self.exceptHandlers[-1]:
 self.report(messages.UndefinedName, node, name)
 self.report(messages.UndefinedLocal,
 scope[name].used[1], name, scope[name].source)
 break
 parent_stmt = self.getParent(node)
-if isinstance(parent_stmt, (FOR_TYPES, ast.comprehension)) or (
+if isinstance(parent_stmt, ANNASSIGN_TYPES) and parent_stmt.value is None:
+binding = Annotation(name, node)
+elif isinstance(parent_stmt, (FOR_TYPES, ast.comprehension)) or (
 parent_stmt != node._pyflakes_parent and
 not self.isLiteralTupleUnpacking(parent_stmt)):
 binding = Binding(name, node)
 elif name == '__all__' and isinstance(self.scope, ModuleScope):
 binding = ExportBinding(name, node._pyflakes_parent, self.scope)
 del self.scope[name]
 except KeyError:
 self.report(messages.UndefinedName, node, name)
 @contextlib.contextmanager
-def _enter_annotation(self):
+def _enter_annotation(self, ann_type=AnnotationState.BARE):
-orig, self._in_annotation = self._in_annotation, True
+orig, self._in_annotation = self._in_annotation, ann_type
 try:
 yield
 finally:
 self._in_annotation = orig
+@property
+def _in_postponed_annotation(self):
+return (
+self._in_annotation == AnnotationState.STRING or
+self.annotationsFutureEnabled
+)
 def _handle_type_comments(self, node):
 for (lineno, col_offset), comment in self._type_comments.get(node, ()):
 comment = comment.split(':', 1)[1].strip()
 func_match = TYPE_FUNC_RE.match(comment)
 self.handleChildren(tree)
 self.offset = node_offset
 self.popScope()
 self.scopeStack = saved_stack
-@in_annotation
+@in_string_annotation
 def handleStringAnnotation(self, s, node, ref_lineno, ref_col_offset, err):
 try:
 tree = ast.parse(s)
 except SyntaxError:
 self.report(err, node, s)
 BOOLOP = UNARYOP = SET = \
 REPR = ATTRIBUTE = \
 STARRED = NAMECONSTANT = NAMEDEXPR = handleChildren
 def SUBSCRIPT(self, node):
-if (
+if _is_name_or_attr(node.value, 'Literal'):
-(
+with self._enter_annotation(AnnotationState.NONE):
-isinstance(node.value, ast.Name) and
-node.value.id == 'Literal'
-) or (
-isinstance(node.value, ast.Attribute) and
-node.value.attr == 'Literal'
-)
-):
-orig, self._in_typing_literal = self._in_typing_literal, True
-try:
 self.handleChildren(node)
-finally:
+elif _is_name_or_attr(node.value, 'Annotated'):
-self._in_typing_literal = orig
+self.handleNode(node.value, node)
+# py39+
+if isinstance(node.slice, ast.Tuple):
+slice_tuple = node.slice
+# <py39
+elif (
+isinstance(node.slice, ast.Index) and
+isinstance(node.slice.value, ast.Tuple)
+):
+slice_tuple = node.slice.value
+else:
+slice_tuple = None
+# not a multi-arg `Annotated`
+if slice_tuple is None or len(slice_tuple.elts) < 2:
+self.handleNode(node.slice, node)
+else:
+# the first argument is the type
+self.handleNode(slice_tuple.elts[0], node)
+# the rest of the arguments are not
+with self._enter_annotation(AnnotationState.NONE):
+for arg in slice_tuple.elts[1:]:
+self.handleNode(arg, node)
+self.handleNode(node.ctx, node)
 else:
 if _is_any_typing_member(node.value, self.scopeStack):
 with self._enter_annotation():
 self.handleChildren(node)
 else:
 isinstance(node.func.value, ast.Str) and
 node.func.attr == 'format'
 ):
 self._handle_string_dot_format(node)
+omit = []
+annotated = []
+not_annotated = []
 if (
 _is_typing(node.func, 'cast', self.scopeStack) and
-len(node.args) >= 1 and
+len(node.args) >= 1
-isinstance(node.args[0], ast.Str)
 ):
 with self._enter_annotation():
 self.handleNode(node.args[0], node)
-self.handleChildren(node)
+elif _is_typing(node.func, 'TypeVar', self.scopeStack):
+# TypeVar("T", "int", "str")
+omit += ["args"]
+annotated += [arg for arg in node.args[1:]]
+# TypeVar("T", bound="str")
+omit += ["keywords"]
+annotated += [k.value for k in node.keywords if k.arg == "bound"]
+not_annotated += [
+(k, ["value"] if k.arg == "bound" else None)
+for k in node.keywords
+]
+elif _is_typing(node.func, "TypedDict", self.scopeStack):
+# TypedDict("a", {"a": int})
+if len(node.args) > 1 and isinstance(node.args[1], ast.Dict):
+omit += ["args"]
+annotated += node.args[1].values
+not_annotated += [
+(arg, ["values"] if i == 1 else None)
+for i, arg in enumerate(node.args)
+]
+# TypedDict("a", a=int)
+omit += ["keywords"]
+annotated += [k.value for k in node.keywords]
+not_annotated += [(k, ["value"]) for k in node.keywords]
+elif _is_typing(node.func, "NamedTuple", self.scopeStack):
+# NamedTuple("a", [("a", int)])
+if (
+len(node.args) > 1 and
+isinstance(node.args[1], (ast.Tuple, ast.List)) and
+all(isinstance(x, (ast.Tuple, ast.List)) and
+len(x.elts) == 2 for x in node.args[1].elts)
+):
+omit += ["args"]
+annotated += [elt.elts[1] for elt in node.args[1].elts]
+not_annotated += [(elt.elts[0], None) for elt in node.args[1].elts]
+not_annotated += [
+(arg, ["elts"] if i == 1 else None)
+for i, arg in enumerate(node.args)
+]
+not_annotated += [(elt, "elts") for elt in node.args[1].elts]
+# NamedTuple("a", a=int)
+omit += ["keywords"]
+annotated += [k.value for k in node.keywords]
+not_annotated += [(k, ["value"]) for k in node.keywords]
+if omit:
+with self._enter_annotation(AnnotationState.NONE):
+for na_node, na_omit in not_annotated:
+self.handleChildren(na_node, omit=na_omit)
+self.handleChildren(node, omit=omit)
+with self._enter_annotation():
+for annotated_node in annotated:
+self.handleNode(annotated_node, node)
+else:
+self.handleChildren(node)
 def _handle_percent_format(self, node):
 try:
 placeholders = parse_percent_format(node.left.s)
 except ValueError:
 ):
 self._handle_percent_format(node)
 self.handleChildren(node)
 def STR(self, node):
-if self._in_annotation and not self._in_typing_literal:
+if self._in_annotation:
 fn = functools.partial(
 self.handleStringAnnotation,
 node.s,
 node,
 node.lineno,
 # Restore.
 if prev_definition:
 self.scope[node.name] = prev_definition
 def ANNASSIGN(self, node):
-if node.value:
+self.handleNode(node.target, node)
-# Only bind the *targets* if the assignment has a value.
-# Otherwise it's not really ast.Store and shouldn't silence
-# UndefinedLocal warnings.
-self.handleNode(node.target, node)
 self.handleAnnotation(node.annotation, node)
 if node.value:
 # If the assignment has value, handle the *value* now.
 self.handleNode(node.value, node)

Mercurial Repositories > eric / file comparison

comparison: eric6/Plugins/CheckerPlugins/SyntaxChecker/pyflakes/checker.py

eric6/Plugins/CheckerPlugins/SyntaxChecker/pyflakes/checker.py