Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.8/site-packages/parso/python/errors.py: 22%

1# -*- coding: utf-8 -*- 

2import codecs 

3import warnings 

4import re 

5from contextlib import contextmanager 

6 

7from parso.normalizer import Normalizer, NormalizerConfig, Issue, Rule 

8from parso.python.tokenize import _get_token_collection 

9 

10_BLOCK_STMTS = ('if_stmt', 'while_stmt', 'for_stmt', 'try_stmt', 'with_stmt') 

11_STAR_EXPR_PARENTS = ('testlist_star_expr', 'testlist_comp', 'exprlist') 

12# This is the maximal block size given by python. 

13_MAX_BLOCK_SIZE = 20 

14_MAX_INDENT_COUNT = 100 

15ALLOWED_FUTURES = ( 

16 'nested_scopes', 'generators', 'division', 'absolute_import', 

17 'with_statement', 'print_function', 'unicode_literals', 'generator_stop', 

18) 

19_COMP_FOR_TYPES = ('comp_for', 'sync_comp_for') 

20 

21 

22def _get_rhs_name(node, version): 

23 type_ = node.type 

24 if type_ == "lambdef": 

25 return "lambda" 

26 elif type_ == "atom": 

27 comprehension = _get_comprehension_type(node) 

28 first, second = node.children[:2] 

29 if comprehension is not None: 

30 return comprehension 

31 elif second.type == "dictorsetmaker": 

32 if version < (3, 8): 

33 return "literal" 

34 else: 

35 if second.children[1] == ":" or second.children[0] == "**": 

36 return "dict display" 

37 else: 

38 return "set display" 

39 elif ( 

40 first == "(" 

41 and (second == ")" 

42 or (len(node.children) == 3 and node.children[1].type == "testlist_comp")) 

43 ): 

44 return "tuple" 

45 elif first == "(": 

46 return _get_rhs_name(_remove_parens(node), version=version) 

47 elif first == "[": 

48 return "list" 

49 elif first == "{" and second == "}": 

50 return "dict display" 

51 elif first == "{" and len(node.children) > 2: 

52 return "set display" 

53 elif type_ == "keyword": 

54 if "yield" in node.value: 

55 return "yield expression" 

56 if version < (3, 8): 

57 return "keyword" 

58 else: 

59 return str(node.value) 

60 elif type_ == "operator" and node.value == "...": 

61 return "Ellipsis" 

62 elif type_ == "comparison": 

63 return "comparison" 

64 elif type_ in ("string", "number", "strings"): 

65 return "literal" 

66 elif type_ == "yield_expr": 

67 return "yield expression" 

68 elif type_ == "test": 

69 return "conditional expression" 

70 elif type_ in ("atom_expr", "power"): 

71 if node.children[0] == "await": 

72 return "await expression" 

73 elif node.children[-1].type == "trailer": 

74 trailer = node.children[-1] 

75 if trailer.children[0] == "(": 

76 return "function call" 

77 elif trailer.children[0] == "[": 

78 return "subscript" 

79 elif trailer.children[0] == ".": 

80 return "attribute" 

81 elif ( 

82 ("expr" in type_ and "star_expr" not in type_) # is a substring 

83 or "_test" in type_ 

84 or type_ in ("term", "factor") 

85 ): 

86 return "operator" 

87 elif type_ == "star_expr": 

88 return "starred" 

89 elif type_ == "testlist_star_expr": 

90 return "tuple" 

91 elif type_ == "fstring": 

92 return "f-string expression" 

93 return type_ # shouldn't reach here 

94 

95 

96def _iter_stmts(scope): 

97 """ 

98 Iterates over all statements and splits up simple_stmt. 

99 """ 

100 for child in scope.children: 

101 if child.type == 'simple_stmt': 

102 for child2 in child.children: 

103 if child2.type == 'newline' or child2 == ';': 

104 continue 

105 yield child2 

106 else: 

107 yield child 

108 

109 

110def _get_comprehension_type(atom): 

111 first, second = atom.children[:2] 

112 if second.type == 'testlist_comp' and second.children[1].type in _COMP_FOR_TYPES: 

113 if first == '[': 

114 return 'list comprehension' 

115 else: 

116 return 'generator expression' 

117 elif second.type == 'dictorsetmaker' and second.children[-1].type in _COMP_FOR_TYPES: 

118 if second.children[1] == ':': 

119 return 'dict comprehension' 

120 else: 

121 return 'set comprehension' 

122 return None 

123 

124 

125def _is_future_import(import_from): 

126 # It looks like a __future__ import that is relative is still a future 

127 # import. That feels kind of odd, but whatever. 

128 # if import_from.level != 0: 

129 # return False 

130 from_names = import_from.get_from_names() 

131 return [n.value for n in from_names] == ['__future__'] 

132 

133 

134def _remove_parens(atom): 

135 """ 

136 Returns the inner part of an expression like `(foo)`. Also removes nested 

137 parens. 

138 """ 

139 try: 

140 children = atom.children 

141 except AttributeError: 

142 pass 

143 else: 

144 if len(children) == 3 and children[0] == '(': 

145 return _remove_parens(atom.children[1]) 

146 return atom 

147 

148 

149def _skip_parens_bottom_up(node): 

150 """ 

151 Returns an ancestor node of an expression, skipping all levels of parens 

152 bottom-up. 

153 """ 

154 while node.parent is not None: 

155 node = node.parent 

156 if node.type != 'atom' or node.children[0] != '(': 

157 return node 

158 return None 

159 

160 

161def _iter_params(parent_node): 

162 return (n for n in parent_node.children if n.type == 'param' or n.type == 'operator') 

163 

164 

165def _is_future_import_first(import_from): 

166 """ 

167 Checks if the import is the first statement of a file. 

168 """ 

169 found_docstring = False 

170 for stmt in _iter_stmts(import_from.get_root_node()): 

171 if stmt.type == 'string' and not found_docstring: 

172 continue 

173 found_docstring = True 

174 

175 if stmt == import_from: 

176 return True 

177 if stmt.type == 'import_from' and _is_future_import(stmt): 

178 continue 

179 return False 

180 

181 

182def _iter_definition_exprs_from_lists(exprlist): 

183 def check_expr(child): 

184 if child.type == 'atom': 

185 if child.children[0] == '(': 

186 testlist_comp = child.children[1] 

187 if testlist_comp.type == 'testlist_comp': 

188 yield from _iter_definition_exprs_from_lists(testlist_comp) 

189 return 

190 else: 

191 # It's a paren that doesn't do anything, like 1 + (1) 

192 yield from check_expr(testlist_comp) 

193 return 

194 elif child.children[0] == '[': 

195 yield testlist_comp 

196 return 

197 yield child 

198 

199 if exprlist.type in _STAR_EXPR_PARENTS: 

200 for child in exprlist.children[::2]: 

201 yield from check_expr(child) 

202 else: 

203 yield from check_expr(exprlist) 

204 

205 

206def _get_expr_stmt_definition_exprs(expr_stmt): 

207 exprs = [] 

208 for list_ in expr_stmt.children[:-2:2]: 

209 if list_.type in ('testlist_star_expr', 'testlist'): 

210 exprs += _iter_definition_exprs_from_lists(list_) 

211 else: 

212 exprs.append(list_) 

213 return exprs 

214 

215 

216def _get_for_stmt_definition_exprs(for_stmt): 

217 exprlist = for_stmt.children[1] 

218 return list(_iter_definition_exprs_from_lists(exprlist)) 

219 

220 

221def _is_argument_comprehension(argument): 

222 return argument.children[1].type in _COMP_FOR_TYPES 

223 

224 

225def _any_fstring_error(version, node): 

226 if version < (3, 9) or node is None: 

227 return False 

228 if node.type == "error_node": 

229 return any(child.type == "fstring_start" for child in node.children) 

230 elif node.type == "fstring": 

231 return True 

232 else: 

233 return node.search_ancestor("fstring") 

234 

235 

236class _Context: 

237 def __init__(self, node, add_syntax_error, parent_context=None): 

238 self.node = node 

239 self.blocks = [] 

240 self.parent_context = parent_context 

241 self._used_name_dict = {} 

242 self._global_names = [] 

243 self._local_params_names = [] 

244 self._nonlocal_names = [] 

245 self._nonlocal_names_in_subscopes = [] 

246 self._add_syntax_error = add_syntax_error 

247 

248 def is_async_funcdef(self): 

249 # Stupidly enough async funcdefs can have two different forms, 

250 # depending if a decorator is used or not. 

251 return self.is_function() \ 

252 and self.node.parent.type in ('async_funcdef', 'async_stmt') 

253 

254 def is_function(self): 

255 return self.node.type == 'funcdef' 

256 

257 def add_name(self, name): 

258 parent_type = name.parent.type 

259 if parent_type == 'trailer': 

260 # We are only interested in first level names. 

261 return 

262 

263 if parent_type == 'global_stmt': 

264 self._global_names.append(name) 

265 elif parent_type == 'nonlocal_stmt': 

266 self._nonlocal_names.append(name) 

267 elif parent_type == 'funcdef': 

268 self._local_params_names.extend( 

269 [param.name.value for param in name.parent.get_params()] 

270 ) 

271 else: 

272 self._used_name_dict.setdefault(name.value, []).append(name) 

273 

274 def finalize(self): 

275 """ 

276 Returns a list of nonlocal names that need to be part of that scope. 

277 """ 

278 self._analyze_names(self._global_names, 'global') 

279 self._analyze_names(self._nonlocal_names, 'nonlocal') 

280 

281 global_name_strs = {n.value: n for n in self._global_names} 

282 for nonlocal_name in self._nonlocal_names: 

283 try: 

284 global_name = global_name_strs[nonlocal_name.value] 

285 except KeyError: 

286 continue 

287 

288 message = "name '%s' is nonlocal and global" % global_name.value 

289 if global_name.start_pos < nonlocal_name.start_pos: 

290 error_name = global_name 

291 else: 

292 error_name = nonlocal_name 

293 self._add_syntax_error(error_name, message) 

294 

295 nonlocals_not_handled = [] 

296 for nonlocal_name in self._nonlocal_names_in_subscopes: 

297 search = nonlocal_name.value 

298 if search in self._local_params_names: 

299 continue 

300 if search in global_name_strs or self.parent_context is None: 

301 message = "no binding for nonlocal '%s' found" % nonlocal_name.value 

302 self._add_syntax_error(nonlocal_name, message) 

303 elif not self.is_function() or \ 

304 nonlocal_name.value not in self._used_name_dict: 

305 nonlocals_not_handled.append(nonlocal_name) 

306 return self._nonlocal_names + nonlocals_not_handled 

307 

308 def _analyze_names(self, globals_or_nonlocals, type_): 

309 def raise_(message): 

310 self._add_syntax_error(base_name, message % (base_name.value, type_)) 

311 

312 params = [] 

313 if self.node.type == 'funcdef': 

314 params = self.node.get_params() 

315 

316 for base_name in globals_or_nonlocals: 

317 found_global_or_nonlocal = False 

318 # Somehow Python does it the reversed way. 

319 for name in reversed(self._used_name_dict.get(base_name.value, [])): 

320 if name.start_pos > base_name.start_pos: 

321 # All following names don't have to be checked. 

322 found_global_or_nonlocal = True 

323 

324 parent = name.parent 

325 if parent.type == 'param' and parent.name == name: 

326 # Skip those here, these definitions belong to the next 

327 # scope. 

328 continue 

329 

330 if name.is_definition(): 

331 if parent.type == 'expr_stmt' \ 

332 and parent.children[1].type == 'annassign': 

333 if found_global_or_nonlocal: 

334 # If it's after the global the error seems to be 

335 # placed there. 

336 base_name = name 

337 raise_("annotated name '%s' can't be %s") 

338 break 

339 else: 

340 message = "name '%s' is assigned to before %s declaration" 

341 else: 

342 message = "name '%s' is used prior to %s declaration" 

343 

344 if not found_global_or_nonlocal: 

345 raise_(message) 

346 # Only add an error for the first occurence. 

347 break 

348 

349 for param in params: 

350 if param.name.value == base_name.value: 

351 raise_("name '%s' is parameter and %s"), 

352 

353 @contextmanager 

354 def add_block(self, node): 

355 self.blocks.append(node) 

356 yield 

357 self.blocks.pop() 

358 

359 def add_context(self, node): 

360 return _Context(node, self._add_syntax_error, parent_context=self) 

361 

362 def close_child_context(self, child_context): 

363 self._nonlocal_names_in_subscopes += child_context.finalize() 

364 

365 

366class ErrorFinder(Normalizer): 

367 """ 

368 Searches for errors in the syntax tree. 

369 """ 

370 def __init__(self, *args, **kwargs): 

371 super().__init__(*args, **kwargs) 

372 self._error_dict = {} 

373 self.version = self.grammar.version_info 

374 

375 def initialize(self, node): 

376 def create_context(node): 

377 if node is None: 

378 return None 

379 

380 parent_context = create_context(node.parent) 

381 if node.type in ('classdef', 'funcdef', 'file_input'): 

382 return _Context(node, self._add_syntax_error, parent_context) 

383 return parent_context 

384 

385 self.context = create_context(node) or _Context(node, self._add_syntax_error) 

386 self._indentation_count = 0 

387 

388 def visit(self, node): 

389 if node.type == 'error_node': 

390 with self.visit_node(node): 

391 # Don't need to investigate the inners of an error node. We 

392 # might find errors in there that should be ignored, because 

393 # the error node itself already shows that there's an issue. 

394 return '' 

395 return super().visit(node) 

396 

397 @contextmanager 

398 def visit_node(self, node): 

399 self._check_type_rules(node) 

400 

401 if node.type in _BLOCK_STMTS: 

402 with self.context.add_block(node): 

403 if len(self.context.blocks) == _MAX_BLOCK_SIZE: 

404 self._add_syntax_error(node, "too many statically nested blocks") 

405 yield 

406 return 

407 elif node.type == 'suite': 

408 self._indentation_count += 1 

409 if self._indentation_count == _MAX_INDENT_COUNT: 

410 self._add_indentation_error(node.children[1], "too many levels of indentation") 

411 

412 yield 

413 

414 if node.type == 'suite': 

415 self._indentation_count -= 1 

416 elif node.type in ('classdef', 'funcdef'): 

417 context = self.context 

418 self.context = context.parent_context 

419 self.context.close_child_context(context) 

420 

421 def visit_leaf(self, leaf): 

422 if leaf.type == 'error_leaf': 

423 if leaf.token_type in ('INDENT', 'ERROR_DEDENT'): 

424 # Indents/Dedents itself never have a prefix. They are just 

425 # "pseudo" tokens that get removed by the syntax tree later. 

426 # Therefore in case of an error we also have to check for this. 

427 spacing = list(leaf.get_next_leaf()._split_prefix())[-1] 

428 if leaf.token_type == 'INDENT': 

429 message = 'unexpected indent' 

430 else: 

431 message = 'unindent does not match any outer indentation level' 

432 self._add_indentation_error(spacing, message) 

433 else: 

434 if leaf.value.startswith('\\'): 

435 message = 'unexpected character after line continuation character' 

436 else: 

437 match = re.match('\\w{,2}("{1,3}|\'{1,3})', leaf.value) 

438 if match is None: 

439 message = 'invalid syntax' 

440 if ( 

441 self.version >= (3, 9) 

442 and leaf.value in _get_token_collection( 

443 self.version 

444 ).always_break_tokens 

445 ): 

446 message = "f-string: " + message 

447 else: 

448 if len(match.group(1)) == 1: 

449 message = 'EOL while scanning string literal' 

450 else: 

451 message = 'EOF while scanning triple-quoted string literal' 

452 self._add_syntax_error(leaf, message) 

453 return '' 

454 elif leaf.value == ':': 

455 parent = leaf.parent 

456 if parent.type in ('classdef', 'funcdef'): 

457 self.context = self.context.add_context(parent) 

458 

459 # The rest is rule based. 

460 return super().visit_leaf(leaf) 

461 

462 def _add_indentation_error(self, spacing, message): 

463 self.add_issue(spacing, 903, "IndentationError: " + message) 

464 

465 def _add_syntax_error(self, node, message): 

466 self.add_issue(node, 901, "SyntaxError: " + message) 

467 

468 def add_issue(self, node, code, message): 

469 # Overwrite the default behavior. 

470 # Check if the issues are on the same line. 

471 line = node.start_pos[0] 

472 args = (code, message, node) 

473 self._error_dict.setdefault(line, args) 

474 

475 def finalize(self): 

476 self.context.finalize() 

477 

478 for code, message, node in self._error_dict.values(): 

479 self.issues.append(Issue(node, code, message)) 

480 

481 

482class IndentationRule(Rule): 

483 code = 903 

484 

485 def _get_message(self, message, node): 

486 message = super()._get_message(message, node) 

487 return "IndentationError: " + message 

488 

489 

490@ErrorFinder.register_rule(type='error_node') 

491class _ExpectIndentedBlock(IndentationRule): 

492 message = 'expected an indented block' 

493 

494 def get_node(self, node): 

495 leaf = node.get_next_leaf() 

496 return list(leaf._split_prefix())[-1] 

497 

498 def is_issue(self, node): 

499 # This is the beginning of a suite that is not indented. 

500 return node.children[-1].type == 'newline' 

501 

502 

503class ErrorFinderConfig(NormalizerConfig): 

504 normalizer_class = ErrorFinder 

505 

506 

507class SyntaxRule(Rule): 

508 code = 901 

509 

510 def _get_message(self, message, node): 

511 message = super()._get_message(message, node) 

512 if ( 

513 "f-string" not in message 

514 and _any_fstring_error(self._normalizer.version, node) 

515 ): 

516 message = "f-string: " + message 

517 return "SyntaxError: " + message 

518 

519 

520@ErrorFinder.register_rule(type='error_node') 

521class _InvalidSyntaxRule(SyntaxRule): 

522 message = "invalid syntax" 

523 fstring_message = "f-string: invalid syntax" 

524 

525 def get_node(self, node): 

526 return node.get_next_leaf() 

527 

528 def is_issue(self, node): 

529 error = node.get_next_leaf().type != 'error_leaf' 

530 if ( 

531 error 

532 and _any_fstring_error(self._normalizer.version, node) 

533 ): 

534 self.add_issue(node, message=self.fstring_message) 

535 else: 

536 # Error leafs will be added later as an error. 

537 return error 

538 

539 

540@ErrorFinder.register_rule(value='await') 

541class _AwaitOutsideAsync(SyntaxRule): 

542 message = "'await' outside async function" 

543 

544 def is_issue(self, leaf): 

545 return not self._normalizer.context.is_async_funcdef() 

546 

547 def get_error_node(self, node): 

548 # Return the whole await statement. 

549 return node.parent 

550 

551 

552@ErrorFinder.register_rule(value='break') 

553class _BreakOutsideLoop(SyntaxRule): 

554 message = "'break' outside loop" 

555 

556 def is_issue(self, leaf): 

557 in_loop = False 

558 for block in self._normalizer.context.blocks: 

559 if block.type in ('for_stmt', 'while_stmt'): 

560 in_loop = True 

561 return not in_loop 

562 

563 

564@ErrorFinder.register_rule(value='continue') 

565class _ContinueChecks(SyntaxRule): 

566 message = "'continue' not properly in loop" 

567 message_in_finally = "'continue' not supported inside 'finally' clause" 

568 

569 def is_issue(self, leaf): 

570 in_loop = False 

571 for block in self._normalizer.context.blocks: 

572 if block.type in ('for_stmt', 'while_stmt'): 

573 in_loop = True 

574 if block.type == 'try_stmt': 

575 last_block = block.children[-3] 

576 if ( 

577 last_block == "finally" 

578 and leaf.start_pos > last_block.start_pos 

579 and self._normalizer.version < (3, 8) 

580 ): 

581 self.add_issue(leaf, message=self.message_in_finally) 

582 return False # Error already added 

583 if not in_loop: 

584 return True 

585 

586 

587@ErrorFinder.register_rule(value='from') 

588class _YieldFromCheck(SyntaxRule): 

589 message = "'yield from' inside async function" 

590 

591 def get_node(self, leaf): 

592 return leaf.parent.parent # This is the actual yield statement. 

593 

594 def is_issue(self, leaf): 

595 return leaf.parent.type == 'yield_arg' \ 

596 and self._normalizer.context.is_async_funcdef() 

597 

598 

599@ErrorFinder.register_rule(type='name') 

600class _NameChecks(SyntaxRule): 

601 message = 'cannot assign to __debug__' 

602 message_none = 'cannot assign to None' 

603 

604 def is_issue(self, leaf): 

605 self._normalizer.context.add_name(leaf) 

606 

607 if leaf.value == '__debug__' and leaf.is_definition(): 

608 return True 

609 

610 

611@ErrorFinder.register_rule(type='string') 

612class _StringChecks(SyntaxRule): 

613 message = "bytes can only contain ASCII literal characters." 

614 

615 def is_issue(self, leaf): 

616 string_prefix = leaf.string_prefix.lower() 

617 if 'b' in string_prefix \ 

618 and any(c for c in leaf.value if ord(c) > 127): 

619 # b'ä' 

620 return True 

621 

622 if 'r' not in string_prefix: 

623 # Raw strings don't need to be checked if they have proper 

624 # escaping. 

625 

626 payload = leaf._get_payload() 

627 if 'b' in string_prefix: 

628 payload = payload.encode('utf-8') 

629 func = codecs.escape_decode 

630 else: 

631 func = codecs.unicode_escape_decode 

632 

633 try: 

634 with warnings.catch_warnings(): 

635 # The warnings from parsing strings are not relevant. 

636 warnings.filterwarnings('ignore') 

637 func(payload) 

638 except UnicodeDecodeError as e: 

639 self.add_issue(leaf, message='(unicode error) ' + str(e)) 

640 except ValueError as e: 

641 self.add_issue(leaf, message='(value error) ' + str(e)) 

642 

643 

644@ErrorFinder.register_rule(value='*') 

645class _StarCheck(SyntaxRule): 

646 message = "named arguments must follow bare *" 

647 

648 def is_issue(self, leaf): 

649 params = leaf.parent 

650 if params.type == 'parameters' and params: 

651 after = params.children[params.children.index(leaf) + 1:] 

652 after = [child for child in after 

653 if child not in (',', ')') and not child.star_count] 

654 return len(after) == 0 

655 

656 

657@ErrorFinder.register_rule(value='**') 

658class _StarStarCheck(SyntaxRule): 

659 # e.g. {**{} for a in [1]} 

660 # TODO this should probably get a better end_pos including 

661 # the next sibling of leaf. 

662 message = "dict unpacking cannot be used in dict comprehension" 

663 

664 def is_issue(self, leaf): 

665 if leaf.parent.type == 'dictorsetmaker': 

666 comp_for = leaf.get_next_sibling().get_next_sibling() 

667 return comp_for is not None and comp_for.type in _COMP_FOR_TYPES 

668 

669 

670@ErrorFinder.register_rule(value='yield') 

671@ErrorFinder.register_rule(value='return') 

672class _ReturnAndYieldChecks(SyntaxRule): 

673 message = "'return' with value in async generator" 

674 message_async_yield = "'yield' inside async function" 

675 

676 def get_node(self, leaf): 

677 return leaf.parent 

678 

679 def is_issue(self, leaf): 

680 if self._normalizer.context.node.type != 'funcdef': 

681 self.add_issue(self.get_node(leaf), message="'%s' outside function" % leaf.value) 

682 elif self._normalizer.context.is_async_funcdef() \ 

683 and any(self._normalizer.context.node.iter_yield_exprs()): 

684 if leaf.value == 'return' and leaf.parent.type == 'return_stmt': 

685 return True 

686 

687 

688@ErrorFinder.register_rule(type='strings') 

689class _BytesAndStringMix(SyntaxRule): 

690 # e.g. 's' b'' 

691 message = "cannot mix bytes and nonbytes literals" 

692 

693 def _is_bytes_literal(self, string): 

694 if string.type == 'fstring': 

695 return False 

696 return 'b' in string.string_prefix.lower() 

697 

698 def is_issue(self, node): 

699 first = node.children[0] 

700 first_is_bytes = self._is_bytes_literal(first) 

701 for string in node.children[1:]: 

702 if first_is_bytes != self._is_bytes_literal(string): 

703 return True 

704 

705 

706@ErrorFinder.register_rule(type='import_as_names') 

707class _TrailingImportComma(SyntaxRule): 

708 # e.g. from foo import a, 

709 message = "trailing comma not allowed without surrounding parentheses" 

710 

711 def is_issue(self, node): 

712 if node.children[-1] == ',' and node.parent.children[-1] != ')': 

713 return True 

714 

715 

716@ErrorFinder.register_rule(type='import_from') 

717class _ImportStarInFunction(SyntaxRule): 

718 message = "import * only allowed at module level" 

719 

720 def is_issue(self, node): 

721 return node.is_star_import() and self._normalizer.context.parent_context is not None 

722 

723 

724@ErrorFinder.register_rule(type='import_from') 

725class _FutureImportRule(SyntaxRule): 

726 message = "from __future__ imports must occur at the beginning of the file" 

727 

728 def is_issue(self, node): 

729 if _is_future_import(node): 

730 if not _is_future_import_first(node): 

731 return True 

732 

733 for from_name, future_name in node.get_paths(): 

734 name = future_name.value 

735 allowed_futures = list(ALLOWED_FUTURES) 

736 if self._normalizer.version >= (3, 7): 

737 allowed_futures.append('annotations') 

738 if name == 'braces': 

739 self.add_issue(node, message="not a chance") 

740 elif name == 'barry_as_FLUFL': 

741 m = "Seriously I'm not implementing this :) ~ Dave" 

742 self.add_issue(node, message=m) 

743 elif name not in allowed_futures: 

744 message = "future feature %s is not defined" % name 

745 self.add_issue(node, message=message) 

746 

747 

748@ErrorFinder.register_rule(type='star_expr') 

749class _StarExprRule(SyntaxRule): 

750 message_iterable_unpacking = "iterable unpacking cannot be used in comprehension" 

751 

752 def is_issue(self, node): 

753 def check_delete_starred(node): 

754 while node.parent is not None: 

755 node = node.parent 

756 if node.type == 'del_stmt': 

757 return True 

758 if node.type not in (*_STAR_EXPR_PARENTS, 'atom'): 

759 return False 

760 return False 

761 

762 if self._normalizer.version >= (3, 9): 

763 ancestor = node.parent 

764 else: 

765 ancestor = _skip_parens_bottom_up(node) 

766 # starred expression not in tuple/list/set 

767 if ancestor.type not in (*_STAR_EXPR_PARENTS, 'dictorsetmaker') \ 

768 and not (ancestor.type == 'atom' and ancestor.children[0] != '('): 

769 self.add_issue(node, message="can't use starred expression here") 

770 return 

771 

772 if check_delete_starred(node): 

773 if self._normalizer.version >= (3, 9): 

774 self.add_issue(node, message="cannot delete starred") 

775 else: 

776 self.add_issue(node, message="can't use starred expression here") 

777 return 

778 

779 if node.parent.type == 'testlist_comp': 

780 # [*[] for a in [1]] 

781 if node.parent.children[1].type in _COMP_FOR_TYPES: 

782 self.add_issue(node, message=self.message_iterable_unpacking) 

783 

784 

785@ErrorFinder.register_rule(types=_STAR_EXPR_PARENTS) 

786class _StarExprParentRule(SyntaxRule): 

787 def is_issue(self, node): 

788 def is_definition(node, ancestor): 

789 if ancestor is None: 

790 return False 

791 

792 type_ = ancestor.type 

793 if type_ == 'trailer': 

794 return False 

795 

796 if type_ == 'expr_stmt': 

797 return node.start_pos < ancestor.children[-1].start_pos