Thread: [javascriptlint-commit] SF.net SVN: javascriptlint: [161] trunk/pyjsl
Status: Beta
Brought to you by:
matthiasmiller
From: <mat...@us...> - 2008-03-04 01:34:41
|
Revision: 161 http://javascriptlint.svn.sourceforge.net/javascriptlint/?rev=161&view=rev Author: matthiasmiller Date: 2008-03-03 17:34:39 -0800 (Mon, 03 Mar 2008) Log Message: ----------- rename pyjsl.parse to pyjsl.htmlparse Modified Paths: -------------- trunk/pyjsl/lint.py Added Paths: ----------- trunk/pyjsl/jsparse.py Removed Paths: ------------- trunk/pyjsl/parse.py Copied: trunk/pyjsl/jsparse.py (from rev 157, trunk/pyjsl/parse.py) =================================================================== --- trunk/pyjsl/jsparse.py (rev 0) +++ trunk/pyjsl/jsparse.py 2008-03-04 01:34:39 UTC (rev 161) @@ -0,0 +1,319 @@ +#!/usr/bin/python +""" Parses a script into nodes. """ +import bisect +import re +import unittest + +import pyspidermonkey +from pyspidermonkey import tok, op + +_tok_names = dict(zip( + [getattr(tok, prop) for prop in dir(tok)], + ['tok.%s' % prop for prop in dir(tok)] +)) + +class NodePos(): + def __init__(self, line, col): + self.line = line + self.col = col + def __cmp__(self, other): + if self.line < other.line: + return -1 + if self.line > other.line: + return 1 + if self.col < other.col: + return -1 + if self.col > other.col: + return 1 + return 0 + def __str__(self): + return '(line %i, col %i)' % (self.line+1, self.col+1) + +class NodePositions(): + " Given a string, allows [x] lookups for NodePos line and column numbers." + def __init__(self, text): + # Find the length of each line and incrementally sum all of the lengths + # to determine the ending position of each line. + self._lines = text.splitlines(True) + lines = [0] + [len(x) for x in self._lines] + for x in range(1, len(lines)): + lines[x] += lines[x-1] + self._line_offsets = lines + def from_offset(self, offset): + line = bisect.bisect(self._line_offsets, offset)-1 + col = offset - self._line_offsets[line] + return NodePos(line, col) + def to_offset(self, pos): + offset = self._line_offsets[pos.line] + pos.col + assert offset <= self._line_offsets[pos.line+1] # out-of-bounds col num + return offset + def text(self, start, end): + assert start <= end + # Trim the ending first in case it's a single line. + lines = self._lines[start.line:end.line+1] + lines[-1] = lines[-1][:end.col+1] + lines[0] = lines[0][start.col:] + return ''.join(lines) + +class NodeRanges(): + def __init__(self): + self._offsets = [] + def add(self, start, end): + i = bisect.bisect_left(self._offsets, start) + if i % 2 == 1: + i -= 1 + start = self._offsets[i] + + end = end + 1 + j = bisect.bisect_left(self._offsets, end) + if j % 2 == 1: + end = self._offsets[j] + j += 1 + + self._offsets[i:j] = [start,end] + def has(self, pos): + return bisect.bisect_right(self._offsets, pos) % 2 == 1 + +class _Node(): + def add_child(self, node): + if node: + node.node_index = len(self.kids) + node.parent = self + self.kids.append(node) + + def start_pos(self): + try: + return self._start_pos + except AttributeError: + self._start_pos = NodePos(self._start_line, self._start_col) + return self._start_pos + + def end_pos(self): + try: + return self._end_pos + except AttributeError: + self._end_pos = NodePos(self._end_line, self._end_col) + return self._end_pos + + def __str__(self): + kind = self.kind + if not kind: + kind = '(none)' + return '%s>%s' % (_tok_names[kind], str(self.kids)) + + def is_equivalent(self, other, are_functions_equiv=False): + if not other: + return False + + # Bail out for functions + if not are_functions_equiv: + if self.kind == tok.FUNCTION: + return False + if self.kind == tok.LP and self.opcode == op.CALL: + return False + + if self.kind != other.kind: + return False + if self.opcode != other.opcode: + return False + + # Check atoms on names, properties, and string constants + if self.kind in (tok.NAME, tok.DOT, tok.STRING) and self.atom != other.atom: + return False + + # Check values on numbers + if self.kind == tok.NUMBER and self.dval != other.dval: + return False + + # Compare child nodes + if len(self.kids) != len(other.kids): + return False + for i in range(0, len(self.kids)): + # Watch for dead nodes + if not self.kids[i]: + if not other.kids[i]: return True + else: return False + if not self.kids[i].is_equivalent(other.kids[i]): + return False + + return True + +def _parse_comments(script, root, node_positions, ignore_ranges): + pos = 0 + single_line_re = r"//[^\r\n]*" + multi_line_re = r"/\*(.*?)\*/" + full_re = "(%s)|(%s)" % (single_line_re, multi_line_re) + comment_re = re.compile(full_re, re.DOTALL) + + comments = [] + while True: + match = comment_re.search(script, pos) + if not match: + return comments + + # Get the comment text + comment_text = script[match.start():match.end()] + if comment_text.startswith('/*'): + comment_text = comment_text[2:-2] + opcode = 'JSOP_C_COMMENT' + else: + comment_text = comment_text[2:] + opcode = 'JSOP_CPP_COMMENT' + opcode = opcode[5:].lower() + + start_offset = match.start()+1 + end_offset = match.end() + + # Make sure it doesn't start in a string or regexp + if not ignore_ranges.has(start_offset): + start_pos = node_positions.from_offset(start_offset) + end_pos = node_positions.from_offset(end_offset) + kwargs = { + 'type': 'COMMENT', + 'atom': comment_text, + 'opcode': opcode, + '_start_line': start_pos.line, + '_start_col': start_pos.col, + '_end_line': end_pos.line, + '_end_col': end_pos.col, + 'parent': None, + 'kids': [], + 'node_index': None + } + comment_node = _Node() + comment_node.__dict__.update(kwargs) + comments.append(comment_node) + pos = match.end() + else: + pos = match.start()+1 + +def parse(script, error_callback): + def _wrapped_callback(line, col, msg): + assert msg.startswith('JSMSG_') + msg = msg[6:].lower() + error_callback(line, col, msg) + + positions = NodePositions(script) + + roots = [] + nodes = [] + comment_ignore_ranges = NodeRanges() + def process(node): + if node.kind == tok.NUMBER: + node.atom = positions.text(node.start_pos(), node.end_pos()) + elif node.kind == tok.STRING or \ + (node.kind == tok.OBJECT and node.opcode == op.REGEXP): + start_offset = positions.to_offset(node.start_pos()) + end_offset = positions.to_offset(node.end_pos()) + comment_ignore_ranges.add(start_offset, end_offset) + for kid in node.kids: + if kid: + process(kid) + def pop(): + nodes.pop() + + roots = pyspidermonkey.traverse(script, _Node, _wrapped_callback) + assert len(roots) == 1 + root_node = roots[0] + process(root_node) + + comments = _parse_comments(script, root_node, positions, comment_ignore_ranges) + return root_node, comments + +def _dump_node(node, depth=0): + print '. '*depth, + if node is None: + print '(none)' + else: + print '%s\t%s, %s' % (_tok_names[node.kind], node.start_pos(), node.end_pos()) + for node in node.kids: + _dump_node(node, depth+1) + +def dump_tree(script): + def error_callback(line, col, msg): + print '(%i, %i): %s', (line, col, msg) + node, comments = parse(script, error_callback) + _dump_node(node) + +class TestComments(unittest.TestCase): + def _test(self, script, expected_comments): + root, comments = parse(script, lambda line, col, msg: None) + encountered_comments = [node.atom for node in comments] + self.assertEquals(encountered_comments, list(expected_comments)) + def testSimpleComments(self): + self._test('re = /\//g', ()) + self._test('re = /\///g', ()) + self._test('re = /\////g', ('g',)) + def testCComments(self): + self._test('/*a*//*b*/', ('a', 'b')) + self._test('/*a\r\na*//*b\r\nb*/', ('a\r\na', 'b\r\nb')) + self._test('a//*b*/c', ('*b*/c',)) + self._test('a///*b*/c', ('/*b*/c',)) + self._test('a/*//*/;', ('//',)) + self._test('a/*b*/+/*c*/d', ('b', 'c')) + +class TestNodePositions(unittest.TestCase): + def _test(self, text, expected_lines, expected_cols): + # Get a NodePos list + positions = NodePositions(text) + positions = [positions.from_offset(i) for i in range(0, len(text))] + encountered_lines = ''.join([str(x.line) for x in positions]) + encountered_cols = ''.join([str(x.col) for x in positions]) + self.assertEquals(encountered_lines, expected_lines.replace(' ', '')) + self.assertEquals(encountered_cols, expected_cols.replace(' ', '')) + def testSimple(self): + self._test( + 'abc\r\ndef\nghi\n\nj', + '0000 0 1111 2222 3 4', + '0123 4 0123 0123 0 0' + ) + self._test( + '\rabc', + '0 111', + '0 012' + ) + def testText(self): + pos = NodePositions('abc\r\ndef\n\nghi') + self.assertEquals(pos.text(NodePos(0, 0), NodePos(0, 0)), 'a') + self.assertEquals(pos.text(NodePos(0, 0), NodePos(0, 2)), 'abc') + self.assertEquals(pos.text(NodePos(0, 2), NodePos(1, 2)), 'c\r\ndef') + def testOffset(self): + pos = NodePositions('abc\r\ndef\n\nghi') + self.assertEquals(pos.to_offset(NodePos(0, 2)), 2) + self.assertEquals(pos.to_offset(NodePos(1, 0)), 5) + self.assertEquals(pos.to_offset(NodePos(3, 1)), 11) + +class TestNodeRanges(unittest.TestCase): + def testAdd(self): + r = NodeRanges() + r.add(5, 10) + self.assertEquals(r._offsets, [5,11]) + r.add(15, 20) + self.assertEquals(r._offsets, [5,11,15,21]) + r.add(21,22) + self.assertEquals(r._offsets, [5,11,15,23]) + r.add(4,5) + self.assertEquals(r._offsets, [4,11,15,23]) + r.add(9,11) + self.assertEquals(r._offsets, [4,12,15,23]) + r.add(10,20) + self.assertEquals(r._offsets, [4,23]) + r.add(4,22) + self.assertEquals(r._offsets, [4,23]) + r.add(30,30) + self.assertEquals(r._offsets, [4,23,30,31]) + def testHas(self): + r = NodeRanges() + r.add(5, 10) + r.add(15, 15) + assert not r.has(4) + assert r.has(5) + assert r.has(6) + assert r.has(9) + assert r.has(10) + assert not r.has(14) + assert r.has(15) + assert not r.has(16) +if __name__ == '__main__': + unittest.main() + Modified: trunk/pyjsl/lint.py =================================================================== --- trunk/pyjsl/lint.py 2008-03-03 22:53:12 UTC (rev 160) +++ trunk/pyjsl/lint.py 2008-03-04 01:34:39 UTC (rev 161) @@ -3,7 +3,7 @@ import re import conf -import parse +import jsparse import visitation import warnings import util @@ -149,7 +149,7 @@ def _lint_script(script, script_cache, lint_error, conf, import_callback): def parse_error(row, col, msg): if not msg in ('redeclared_var', 'var_hides_arg'): - parse_errors.append((parse.NodePos(row, col), msg)) + parse_errors.append((jsparse.NodePos(row, col), msg)) def report(node, errname): _report(node.start_pos(), errname, True) @@ -169,7 +169,7 @@ return lint_error(pos.line, pos.col, errname) parse_errors = [] - root, comments = parse.parse(script, parse_error) + root, comments = jsparse.parse(script, parse_error) ignores = [] start_ignore = None declares = [] Deleted: trunk/pyjsl/parse.py =================================================================== --- trunk/pyjsl/parse.py 2008-03-03 22:53:12 UTC (rev 160) +++ trunk/pyjsl/parse.py 2008-03-04 01:34:39 UTC (rev 161) @@ -1,321 +0,0 @@ -#!/usr/bin/python -""" Parses a script into nodes. """ -import bisect -import re -import unittest - -import pyspidermonkey -from pyspidermonkey import tok, op - -_tok_names = dict(zip( - [getattr(tok, prop) for prop in dir(tok)], - ['tok.%s' % prop for prop in dir(tok)] -)) -_op_names = dict(zip( - [getattr(op, prop) for prop in dir(op)], - ['op.%s' % prop for prop in dir(op)] -)) - -class NodePos(): - def __init__(self, line, col): - self.line = line - self.col = col - def __cmp__(self, other): - if self.line < other.line: - return -1 - if self.line > other.line: - return 1 - if self.col < other.col: - return -1 - if self.col > other.col: - return 1 - return 0 - def __str__(self): - return '(line %i, col %i)' % (self.line+1, self.col+1) - -class NodePositions(): - " Given a string, allows [x] lookups for NodePos line and column numbers." - def __init__(self, text): - # Find the length of each line and incrementally sum all of the lengths - # to determine the ending position of each line. - self._lines = text.splitlines(True) - lines = [0] + [len(x) for x in self._lines] - for x in range(1, len(lines)): - lines[x] += lines[x-1] - self._line_offsets = lines - def from_offset(self, offset): - line = bisect.bisect(self._line_offsets, offset)-1 - col = offset - self._line_offsets[line] - return NodePos(line, col) - def to_offset(self, pos): - offset = self._line_offsets[pos.line] + pos.col - assert offset <= self._line_offsets[pos.line+1] # out-of-bounds col num - return offset - def text(self, start, end): - assert start <= end - # Trim the ending first in case it's a single line. - lines = self._lines[start.line:end.line+1] - lines[-1] = lines[-1][:end.col+1] - lines[0] = lines[0][start.col:] - return ''.join(lines) - -class NodeRanges(): - def __init__(self): - self._offsets = [] - def add(self, start, end): - i = bisect.bisect_left(self._offsets, start) - if i % 2 == 1: - i -= 1 - start = self._offsets[i] - - end = end + 1 - j = bisect.bisect_left(self._offsets, end) - if j % 2 == 1: - end = self._offsets[j] - j += 1 - - self._offsets[i:j] = [start,end] - def has(self, pos): - return bisect.bisect_right(self._offsets, pos) % 2 == 1 - -class _Node(): - def add_child(self, node): - if node: - node.node_index = len(self.kids) - node.parent = self - self.kids.append(node) - - def start_pos(self): - try: - return self._start_pos - except AttributeError: - self._start_pos = NodePos(self._start_line, self._start_col) - return self._start_pos - - def end_pos(self): - try: - return self._end_pos - except AttributeError: - self._end_pos = NodePos(self._end_line, self._end_col) - return self._end_pos - - def __str__(self): - kind = self.kind - if not kind: - kind = '(none)' - return '%s>%s' % (_tok_names[kind], str(self.kids)) - - def is_equivalent(self, other, are_functions_equiv=False): - if not other: - return False - - # Bail out for functions - if not are_functions_equiv: - if self.kind == tok.FUNCTION: - return False - if self.kind == tok.LP and self.opcode == op.CALL: - return False - - if self.kind != other.kind: - return False - if self.opcode != other.opcode: - return False - - # Check atoms on names, properties, and string constants - if self.kind in (tok.NAME, tok.DOT, tok.STRING) and self.atom != other.atom: - return False - - # Check values on numbers - if self.kind == tok.NUMBER and self.dval != other.dval: - return False - - # Compare child nodes - if len(self.kids) != len(other.kids): - return False - for i in range(0, len(self.kids)): - # Watch for dead nodes - if not self.kids[i]: - if not other.kids[i]: return True - else: return False - if not self.kids[i].is_equivalent(other.kids[i]): - return False - - return True - -def _parse_comments(script, root, node_positions, ignore_ranges): - pos = 0 - single_line_re = r"//[^\r\n]*" - multi_line_re = r"/\*(.*?)\*/" - full_re = "(%s)|(%s)" % (single_line_re, multi_line_re) - comment_re = re.compile(full_re, re.DOTALL) - - comments = [] - while True: - match = comment_re.search(script, pos) - if not match: - return comments - - # Get the comment text - comment_text = script[match.start():match.end()] - if comment_text.startswith('/*'): - comment_text = comment_text[2:-2] - opcode = 'JSOP_C_COMMENT' - else: - comment_text = comment_text[2:] - opcode = 'JSOP_CPP_COMMENT' - opcode = opcode[5:].lower() - - start_offset = match.start()+1 - end_offset = match.end() - - # Make sure it doesn't start in a string or regexp - if not ignore_ranges.has(start_offset): - start_pos = node_positions.from_offset(start_offset) - end_pos = node_positions.from_offset(end_offset) - kwargs = { - 'type': 'COMMENT', - 'atom': comment_text, - 'opcode': opcode, - '_start_line': start_pos.line, - '_start_col': start_pos.col, - '_end_line': end_pos.line, - '_end_col': end_pos.col, - 'parent': None, - 'kids': [], - 'node_index': None - } - comment_node = _Node() - comment_node.__dict__.update(kwargs) - comments.append(comment_node) - pos = match.end() - else: - pos = match.start()+1 - -def parse(script, error_callback): - def _wrapped_callback(line, col, msg): - assert msg.startswith('JSMSG_') - msg = msg[6:].lower() - error_callback(line, col, msg) - - positions = NodePositions(script) - - roots = [] - nodes = [] - comment_ignore_ranges = NodeRanges() - def process(node): - if node.kind == tok.NUMBER: - node.atom = positions.text(node.start_pos(), node.end_pos()) - elif node.kind == tok.STRING or \ - (node.kind == tok.OBJECT and node.opcode == op.REGEXP): - start_offset = positions.to_offset(node.start_pos()) - end_offset = positions.to_offset(node.end_pos()) - comment_ignore_ranges.add(start_offset, end_offset) - for kid in node.kids: - if kid: - process(kid) - - roots = pyspidermonkey.traverse(script, _Node, _wrapped_callback) - assert len(roots) == 1 - root_node = roots[0] - process(root_node) - - comments = _parse_comments(script, root_node, positions, comment_ignore_ranges) - return root_node, comments - -def _dump_node(node, depth=0): - print '. '*depth, - if node is None: - print '(none)' - else: - print '%s, %s\tfrom %s to %s' % (_tok_names[node.kind], _op_names[node.opcode], node.start_pos(), node.end_pos()) - for node in node.kids: - _dump_node(node, depth+1) - -def dump_tree(script): - def error_callback(line, col, msg): - print '(%i, %i): %s', (line, col, msg) - node, comments = parse(script, error_callback) - _dump_node(node) - -class TestComments(unittest.TestCase): - def _test(self, script, expected_comments): - root, comments = parse(script, lambda line, col, msg: None) - encountered_comments = [node.atom for node in comments] - self.assertEquals(encountered_comments, list(expected_comments)) - def testSimpleComments(self): - self._test('re = /\//g', ()) - self._test('re = /\///g', ()) - self._test('re = /\////g', ('g',)) - def testCComments(self): - self._test('/*a*//*b*/', ('a', 'b')) - self._test('/*a\r\na*//*b\r\nb*/', ('a\r\na', 'b\r\nb')) - self._test('a//*b*/c', ('*b*/c',)) - self._test('a///*b*/c', ('/*b*/c',)) - self._test('a/*//*/;', ('//',)) - self._test('a/*b*/+/*c*/d', ('b', 'c')) - -class TestNodePositions(unittest.TestCase): - def _test(self, text, expected_lines, expected_cols): - # Get a NodePos list - positions = NodePositions(text) - positions = [positions.from_offset(i) for i in range(0, len(text))] - encountered_lines = ''.join([str(x.line) for x in positions]) - encountered_cols = ''.join([str(x.col) for x in positions]) - self.assertEquals(encountered_lines, expected_lines.replace(' ', '')) - self.assertEquals(encountered_cols, expected_cols.replace(' ', '')) - def testSimple(self): - self._test( - 'abc\r\ndef\nghi\n\nj', - '0000 0 1111 2222 3 4', - '0123 4 0123 0123 0 0' - ) - self._test( - '\rabc', - '0 111', - '0 012' - ) - def testText(self): - pos = NodePositions('abc\r\ndef\n\nghi') - self.assertEquals(pos.text(NodePos(0, 0), NodePos(0, 0)), 'a') - self.assertEquals(pos.text(NodePos(0, 0), NodePos(0, 2)), 'abc') - self.assertEquals(pos.text(NodePos(0, 2), NodePos(1, 2)), 'c\r\ndef') - def testOffset(self): - pos = NodePositions('abc\r\ndef\n\nghi') - self.assertEquals(pos.to_offset(NodePos(0, 2)), 2) - self.assertEquals(pos.to_offset(NodePos(1, 0)), 5) - self.assertEquals(pos.to_offset(NodePos(3, 1)), 11) - -class TestNodeRanges(unittest.TestCase): - def testAdd(self): - r = NodeRanges() - r.add(5, 10) - self.assertEquals(r._offsets, [5,11]) - r.add(15, 20) - self.assertEquals(r._offsets, [5,11,15,21]) - r.add(21,22) - self.assertEquals(r._offsets, [5,11,15,23]) - r.add(4,5) - self.assertEquals(r._offsets, [4,11,15,23]) - r.add(9,11) - self.assertEquals(r._offsets, [4,12,15,23]) - r.add(10,20) - self.assertEquals(r._offsets, [4,23]) - r.add(4,22) - self.assertEquals(r._offsets, [4,23]) - r.add(30,30) - self.assertEquals(r._offsets, [4,23,30,31]) - def testHas(self): - r = NodeRanges() - r.add(5, 10) - r.add(15, 15) - assert not r.has(4) - assert r.has(5) - assert r.has(6) - assert r.has(9) - assert r.has(10) - assert not r.has(14) - assert r.has(15) - assert not r.has(16) -if __name__ == '__main__': - unittest.main() - This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <mat...@us...> - 2008-03-20 20:48:41
|
Revision: 168 http://javascriptlint.svn.sourceforge.net/javascriptlint/?rev=168&view=rev Author: matthiasmiller Date: 2008-03-20 13:48:39 -0700 (Thu, 20 Mar 2008) Log Message: ----------- various fixes for Python 2.4 Modified Paths: -------------- trunk/pyjsl/conf.py trunk/pyjsl/jsparse.py trunk/pyjsl/lint.py Modified: trunk/pyjsl/conf.py =================================================================== --- trunk/pyjsl/conf.py 2008-03-04 15:15:14 UTC (rev 167) +++ trunk/pyjsl/conf.py 2008-03-20 20:48:39 UTC (rev 168) @@ -8,7 +8,7 @@ self.lineno = None self.path = None -class Setting(): +class Setting: wants_parm = False wants_dir = False @@ -48,7 +48,7 @@ parm = os.path.join(dir, parm) self.value.append((self._recurse.value, parm)) -class Conf(): +class Conf: def __init__(self): recurse = BooleanSetting(False) self._settings = { @@ -94,7 +94,8 @@ assert not '\n' in line # Allow comments - line = line.partition('#')[0] + if '#' in line: + line = line[:line.find('#')] line = line.rstrip() if not line: return Modified: trunk/pyjsl/jsparse.py =================================================================== --- trunk/pyjsl/jsparse.py 2008-03-04 15:15:14 UTC (rev 167) +++ trunk/pyjsl/jsparse.py 2008-03-20 20:48:39 UTC (rev 168) @@ -12,7 +12,7 @@ ['tok.%s' % prop for prop in dir(tok)] )) -class NodePos(): +class NodePos: def __init__(self, line, col): self.line = line self.col = col @@ -29,7 +29,7 @@ def __str__(self): return '(line %i, col %i)' % (self.line+1, self.col+1) -class NodePositions(): +class NodePositions: " Given a string, allows [x] lookups for NodePos line and column numbers." def __init__(self, text): # Find the length of each line and incrementally sum all of the lengths @@ -55,7 +55,7 @@ lines[0] = lines[0][start.col:] return ''.join(lines) -class NodeRanges(): +class NodeRanges: def __init__(self): self._offsets = [] def add(self, start, end): @@ -74,7 +74,7 @@ def has(self, pos): return bisect.bisect_right(self._offsets, pos) % 2 == 1 -class _Node(): +class _Node: def add_child(self, node): if node: node.node_index = len(self.kids) Modified: trunk/pyjsl/lint.py =================================================================== --- trunk/pyjsl/lint.py 2008-03-04 15:15:14 UTC (rev 167) +++ trunk/pyjsl/lint.py 2008-03-20 20:48:39 UTC (rev 168) @@ -70,7 +70,7 @@ parms = control_comment[len(keyword):].strip() return (comment, keyword, parms) -class Scope(): +class Scope: def __init__(self, node): self._is_with_scope = node.kind == tok.WITH self._parent = None This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <mat...@us...> - 2008-04-25 21:39:53
|
Revision: 193 http://javascriptlint.svn.sourceforge.net/javascriptlint/?rev=193&view=rev Author: matthiasmiller Date: 2008-04-25 14:39:29 -0700 (Fri, 25 Apr 2008) Log Message: ----------- Allow node visitors to specify an event (e.g. "push" vs. "pop"). Modified Paths: -------------- trunk/pyjsl/lint.py trunk/pyjsl/visitation.py trunk/pyjsl/warnings.py Modified: trunk/pyjsl/lint.py =================================================================== --- trunk/pyjsl/lint.py 2008-04-25 21:16:20 UTC (rev 192) +++ trunk/pyjsl/lint.py 2008-04-25 21:39:29 UTC (rev 193) @@ -217,7 +217,7 @@ for pos, msg in parse_errors: _report(pos, msg, False) - visitors = visitation.make_visitors(warnings.klasses) + visitors = visitation.make_visitors(warnings.klasses)['push'] assert not script_cache imports = script_cache['imports'] = set() Modified: trunk/pyjsl/visitation.py =================================================================== --- trunk/pyjsl/visitation.py 2008-04-25 21:16:20 UTC (rev 192) +++ trunk/pyjsl/visitation.py 2008-04-25 21:39:29 UTC (rev 193) @@ -3,11 +3,12 @@ traverse the tree to generate warnings. """ -def visit(*args): +def visit(event, *args): """ This decorator is used to indicate which nodes the function should examine. The function should accept (self, node) and return the relevant node or None. """ def _decorate(fn): + fn._visit_event = event fn._visit_nodes = args return fn return _decorate @@ -27,10 +28,17 @@ # Look for functions with the "_visit_nodes" property. visitor = klass() for func in [getattr(visitor, name) for name in dir(visitor)]: + event_visitors = None for node_kind in getattr(func, '_visit_nodes', ()): + # Group visitors by event (e.g. push vs pop) + if not event_visitors: + if not func._visit_event in visitors: + visitors[func._visit_event] = {} + event_visitors = visitors[func._visit_event] + # Map from node_kind to the function if not node_kind in visitors: - visitors[node_kind] = [] - visitors[node_kind].append(func) + event_visitors[node_kind] = [] + event_visitors[node_kind].append(func) return visitors Modified: trunk/pyjsl/warnings.py =================================================================== --- trunk/pyjsl/warnings.py 2008-04-25 21:16:20 UTC (rev 192) +++ trunk/pyjsl/warnings.py 2008-04-25 21:39:29 UTC (rev 193) @@ -4,7 +4,7 @@ underscores. Its docstring should be the warning message. The class can have one more more member functions to inspect nodes. The -function should be decorated with a @lookat call specifying the nodes it +function should be decorated with a @onpush call specifying the nodes it wants to examine. The node names may be in the tok.KIND or (tok.KIND, op.OPCODE) format. To report a warning, the function should return the node causing the warning. @@ -13,7 +13,7 @@ class warning_name: 'questionable JavaScript coding style' - @lookat(tok.NODEKIND, (tok.NODEKIND, op.OPCODE)) + @onpush(tok.NODEKIND, (tok.NODEKIND, op.OPCODE)) def _lint(self, node): if questionable: return node @@ -22,11 +22,14 @@ import sys import types -from visitation import visit as lookat +import visitation from pyspidermonkey import tok, op # TODO: document inspect, node:opcode, etc +def onpush(*args): + return visitation.visit('push', *args) + def _get_branch_in_for(node): " Returns None if this is not one of the branches in a 'for' " if node.parent and node.parent.kind == tok.RESERVED and \ @@ -119,7 +122,7 @@ class comparison_type_conv: 'comparisons against null, 0, true, false, or an empty string allowing implicit type conversion (use === or !==)' - @lookat((tok.EQOP, op.EQ)) + @onpush((tok.EQOP, op.EQ)) def _lint(self, node): lvalue, rvalue = node.kids if not self._allow_coercive_compare(lvalue) or \ @@ -136,7 +139,7 @@ class default_not_at_end: 'the default case is not at the end of the switch statement' - @lookat(tok.DEFAULT) + @onpush(tok.DEFAULT) def _lint(self, node): siblings = node.parent.kids if node.node_index != len(siblings)-1: @@ -144,7 +147,7 @@ class duplicate_case_in_switch: 'duplicate case in switch statement' - @lookat(tok.CASE) + @onpush(tok.CASE) def _lint(self, node): # Only look at previous siblings siblings = node.parent.kids @@ -159,7 +162,7 @@ class missing_default_case: 'missing default case in switch statement' - @lookat(tok.SWITCH) + @onpush(tok.SWITCH) def _lint(self, node): value, cases = node.kids for case in cases.kids: @@ -169,13 +172,13 @@ class with_statement: 'with statement hides undeclared variables; use temporary variable instead' - @lookat(tok.WITH) + @onpush(tok.WITH) def _lint(self, node): return node class useless_comparison: 'useless comparison; comparing identical expressions' - @lookat(tok.EQOP,tok.RELOP) + @onpush(tok.EQOP,tok.RELOP) def _lint(self, node): lvalue, rvalue = node.kids if lvalue.is_equivalent(rvalue): @@ -183,20 +186,20 @@ class use_of_label: 'use of label' - @lookat((tok.COLON, op.NAME)) + @onpush((tok.COLON, op.NAME)) def _lint(self, node): return node class meaningless_block: 'meaningless block; curly braces have no impact' - @lookat(tok.LC) + @onpush(tok.LC) def _lint(self, node): if node.parent and node.parent.kind == tok.LC: return node class misplaced_regex: 'regular expressions should be preceded by a left parenthesis, assignment, colon, or comma' - @lookat((tok.OBJECT, op.REGEXP)) + @onpush((tok.OBJECT, op.REGEXP)) def _lint(self, node): if node.parent.kind == tok.NAME and node.parent.opcode == op.SETNAME: return # Allow in var statements @@ -214,14 +217,14 @@ class assign_to_function_call: 'assignment to a function call' - @lookat(tok.ASSIGN) + @onpush(tok.ASSIGN) def _lint(self, node): if node.kids[0].kind == tok.LP: return node class ambiguous_else_stmt: 'the else statement could be matched with one of multiple if statements (use curly braces to indicate intent' - @lookat(tok.IF) + @onpush(tok.IF) def _lint(self, node): # Only examine this node if it has an else statement. condition, if_, else_ = node.kids @@ -240,7 +243,7 @@ class block_without_braces: 'block statement without curly braces' - @lookat(tok.IF, tok.WHILE, tok.DO, tok.FOR, tok.WITH) + @onpush(tok.IF, tok.WHILE, tok.DO, tok.FOR, tok.WITH) def _lint(self, node): if node.kids[1].kind != tok.LC: return node.kids[1] @@ -248,7 +251,7 @@ class ambiguous_nested_stmt: 'block statements containing block statements should use curly braces to resolve ambiguity' _block_nodes = (tok.IF, tok.WHILE, tok.DO, tok.FOR, tok.WITH) - @lookat(*_block_nodes) + @onpush(*_block_nodes) def _lint(self, node): # Ignore "else if" if node.kind == tok.IF and node.node_index == 2 and node.parent.kind == tok.IF: @@ -262,7 +265,7 @@ class inc_dec_within_stmt: 'increment (++) and decrement (--) operators used as part of greater statement' - @lookat(tok.INC, tok.DEC) + @onpush(tok.INC, tok.DEC) def _lint(self, node): if node.parent.kind == tok.SEMI: return None @@ -287,7 +290,7 @@ class comma_separated_stmts: 'multiple statements separated by commas (use semicolons?)' - @lookat(tok.COMMA) + @onpush(tok.COMMA) def _lint(self, node): # Allow within the first and third part of "for(;;)" if _get_branch_in_for(node) in (0, 2): @@ -299,11 +302,11 @@ class empty_statement: 'empty statement or extra semicolon' - @lookat(tok.SEMI) + @onpush(tok.SEMI) def _semi(self, node): if not node.kids[0]: return node - @lookat(tok.LC) + @onpush(tok.LC) def _lc(self, node): if node.kids: return @@ -317,7 +320,7 @@ class missing_break: 'missing break statement' - @lookat(tok.CASE, tok.DEFAULT) + @onpush(tok.CASE, tok.DEFAULT) def _lint(self, node): # The last item is handled separately if node.node_index == len(node.parent.kids)-1: @@ -333,7 +336,7 @@ class missing_break_for_last_case: 'missing break statement for last case in switch' - @lookat(tok.CASE, tok.DEFAULT) + @onpush(tok.CASE, tok.DEFAULT) def _lint(self, node): if node.node_index < len(node.parent.kids)-1: return @@ -344,18 +347,18 @@ class multiple_plus_minus: 'unknown order of operations for successive plus (e.g. x+++y) or minus (e.g. x---y) signs' - @lookat(tok.INC) + @onpush(tok.INC) def _inc(self, node): if node.node_index == 0 and node.parent.kind == tok.PLUS: return node - @lookat(tok.DEC) + @onpush(tok.DEC) def _dec(self, node): if node.node_index == 0 and node.parent.kind == tok.MINUS: return node class useless_assign: 'useless assignment' - @lookat((tok.NAME, op.SETNAME)) + @onpush((tok.NAME, op.SETNAME)) def _lint(self, node): if node.parent.kind == tok.ASSIGN: assert node.node_index == 0 @@ -367,7 +370,7 @@ class unreachable_code: 'unreachable code' - @lookat(tok.BREAK, tok.CONTINUE, tok.RETURN, tok.THROW) + @onpush(tok.BREAK, tok.CONTINUE, tok.RETURN, tok.THROW) def _lint(self, node): if node.parent.kind == tok.LC and \ node.node_index != len(node.parent.kids)-1: @@ -375,44 +378,44 @@ class meaningless_block: 'meaningless block; curly braces have no impact' - #TODO: @lookat(tok.IF) + #TODO: @onpush(tok.IF) def _lint(self, node): condition, if_, else_ = node.kids if condition.kind == tok.PRIMARY and condition.opcode in (op.TRUE, op.FALSE, op.NULL): return condition - #TODO: @lookat(tok.WHILE) + #TODO: @onpush(tok.WHILE) def _lint(self, node): condition = node.kids[0] if condition.kind == tok.PRIMARY and condition.opcode in (op.FALSE, op.NULL): return condition - @lookat(tok.LC) + @onpush(tok.LC) def _lint(self, node): if node.parent and node.parent.kind == tok.LC: return node class useless_void: 'use of the void type may be unnecessary (void is always undefined)' - @lookat((tok.UNARYOP, op.VOID)) + @onpush((tok.UNARYOP, op.VOID)) def _lint(self, node): return node class parseint_missing_radix: 'parseInt missing radix parameter' - @lookat((tok.LP, op.CALL)) + @onpush((tok.LP, op.CALL)) def _lint(self, node): if node.kids[0].kind == tok.NAME and node.kids[0].atom == 'parseInt' and len(node.kids) <= 2: return node class leading_decimal_point: 'leading decimal point may indicate a number or an object member' - @lookat(tok.NUMBER) + @onpush(tok.NUMBER) def _lint(self, node): if node.atom.startswith('.'): return node class trailing_decimal_point: 'trailing decimal point may indicate a number or an object member' - @lookat(tok.NUMBER) + @onpush(tok.NUMBER) def _lint(self, node): if node.parent.kind == tok.DOT: return node @@ -422,21 +425,21 @@ class octal_number: 'leading zeros make an octal number' _regexp = re.compile('^0[0-9]') - @lookat(tok.NUMBER) + @onpush(tok.NUMBER) def _line(self, node): if self._regexp.match(node.atom): return node class trailing_comma_in_array: 'extra comma is not recommended in array initializers' - @lookat(tok.RB) + @onpush(tok.RB) def _line(self, node): if node.end_comma: return node class useless_quotes: 'the quotation marks are unnecessary' - @lookat(tok.STRING) + @onpush(tok.STRING) def _lint(self, node): if node.node_index == 0 and node.parent.kind == tok.COLON: return node This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <mat...@us...> - 2008-04-25 21:52:36
|
Revision: 194 http://javascriptlint.svn.sourceforge.net/javascriptlint/?rev=194&view=rev Author: matthiasmiller Date: 2008-04-25 14:52:35 -0700 (Fri, 25 Apr 2008) Log Message: ----------- Change visitors to raise an exception instead of return the invalid node. Modified Paths: -------------- trunk/pyjsl/lint.py trunk/pyjsl/warnings.py Modified: trunk/pyjsl/lint.py =================================================================== --- trunk/pyjsl/lint.py 2008-04-25 21:39:29 UTC (rev 193) +++ trunk/pyjsl/lint.py 2008-04-25 21:52:35 UTC (rev 194) @@ -260,9 +260,11 @@ for kind in (node.kind, (node.kind, node.opcode)): if kind in visitors: for visitor in visitors[kind]: - warning_node = visitor(node) - if warning_node: - report(warning_node, visitor.im_class.__name__) + try: + ret = visitor(node) + assert ret is None, 'visitor should raise an exception, not return a value' + except warnings.LintWarning, warning: + report(warning.node, visitor.im_class.__name__) if node.kind == tok.NAME: if node.node_index == 0 and node.parent.kind == tok.COLON and node.parent.parent.kind == tok.RC: Modified: trunk/pyjsl/warnings.py =================================================================== --- trunk/pyjsl/warnings.py 2008-04-25 21:39:29 UTC (rev 193) +++ trunk/pyjsl/warnings.py 2008-04-25 21:52:35 UTC (rev 194) @@ -30,6 +30,10 @@ def onpush(*args): return visitation.visit('push', *args) +class LintWarning(Exception): + def __init__(self, node): + self.node = node + def _get_branch_in_for(node): " Returns None if this is not one of the branches in a 'for' " if node.parent and node.parent.kind == tok.RESERVED and \ @@ -124,18 +128,14 @@ 'comparisons against null, 0, true, false, or an empty string allowing implicit type conversion (use === or !==)' @onpush((tok.EQOP, op.EQ)) def _lint(self, node): - lvalue, rvalue = node.kids - if not self._allow_coercive_compare(lvalue) or \ - not self._allow_coercive_compare(rvalue): - return node - def _allow_coercive_compare(self, node): - if node.kind == tok.PRIMARY and node.opcode in (op.NULL, op.TRUE, op.FALSE): - return False - if node.kind == tok.NUMBER and not node.dval: - return False - if node.kind == tok.STRING and not node.atom: - return False - return True + for kid in node.kids: + if kid.kind == tok.PRIMARY and kid.opcode in (op.NULL, op.TRUE, op.FALSE): + continue + if kid.kind == tok.NUMBER and not kid.dval: + continue + if kid.kind == tok.STRING and not kid.atom: + continue + raise LintWarning, kid class default_not_at_end: 'the default case is not at the end of the switch statement' @@ -143,7 +143,7 @@ def _lint(self, node): siblings = node.parent.kids if node.node_index != len(siblings)-1: - return siblings[node.node_index+1] + raise LintWarning, siblings[node.node_index+1] class duplicate_case_in_switch: 'duplicate case in switch statement' @@ -158,7 +158,7 @@ if sibling.kind == tok.CASE: sibling_value = sibling.kids[0] if node_value.is_equivalent(sibling_value, True): - return node + raise LintWarning, node class missing_default_case: 'missing default case in switch statement' @@ -168,13 +168,13 @@ for case in cases.kids: if case.kind == tok.DEFAULT: return - return node + raise LintWarning, node class with_statement: 'with statement hides undeclared variables; use temporary variable instead' @onpush(tok.WITH) def _lint(self, node): - return node + raise LintWarning, node class useless_comparison: 'useless comparison; comparing identical expressions' @@ -182,20 +182,20 @@ def _lint(self, node): lvalue, rvalue = node.kids if lvalue.is_equivalent(rvalue): - return node + raise LintWarning, node class use_of_label: 'use of label' @onpush((tok.COLON, op.NAME)) def _lint(self, node): - return node + raise LintWarning, node class meaningless_block: 'meaningless block; curly braces have no impact' @onpush(tok.LC) def _lint(self, node): if node.parent and node.parent.kind == tok.LC: - return node + raise LintWarning, node class misplaced_regex: 'regular expressions should be preceded by a left parenthesis, assignment, colon, or comma' @@ -213,14 +213,14 @@ return # Allow in /re/.property if node.parent.kind == tok.RETURN: return # Allow for return values - return node + raise LintWarning, node class assign_to_function_call: 'assignment to a function call' @onpush(tok.ASSIGN) def _lint(self, node): if node.kids[0].kind == tok.LP: - return node + raise LintWarning, node class ambiguous_else_stmt: 'the else statement could be matched with one of multiple if statements (use curly braces to indicate intent' @@ -238,7 +238,7 @@ return # Else is only ambiguous in the first branch of an if statement. if tmp.parent.kind == tok.IF and tmp.node_index == 1: - return else_ + raise LintWarning, else_ tmp = tmp.parent class block_without_braces: @@ -246,7 +246,7 @@ @onpush(tok.IF, tok.WHILE, tok.DO, tok.FOR, tok.WITH) def _lint(self, node): if node.kids[1].kind != tok.LC: - return node.kids[1] + raise LintWarning, node.kids[1] class ambiguous_nested_stmt: 'block statements containing block statements should use curly braces to resolve ambiguity' @@ -261,14 +261,14 @@ # was inside a block statement without clarifying curlies. # (Otherwise, the node type would be tok.LC.) if node.parent.kind in self._block_nodes: - return node + raise LintWarning, node class inc_dec_within_stmt: 'increment (++) and decrement (--) operators used as part of greater statement' @onpush(tok.INC, tok.DEC) def _lint(self, node): if node.parent.kind == tok.SEMI: - return None + return # Allow within the third part of the "for" tmp = node @@ -277,9 +277,9 @@ if tmp and tmp.node_index == 2 and \ tmp.parent.kind == tok.RESERVED and \ tmp.parent.parent.kind == tok.FOR: - return None + return - return node + raise LintWarning, node def _is_for_ternary_stmt(self, node, branch=None): if node.parent and node.parent.kind == tok.COMMA: return _is_for_ternary_stmt(node.parent, branch) @@ -298,14 +298,14 @@ # This is an array if node.parent.kind == tok.RB: return - return node + raise LintWarning, node class empty_statement: 'empty statement or extra semicolon' @onpush(tok.SEMI) def _semi(self, node): if not node.kids[0]: - return node + raise LintWarning, node @onpush(tok.LC) def _lc(self, node): if node.kids: @@ -316,7 +316,7 @@ # Some empty blocks are meaningful. if node.parent.kind in (tok.CATCH, tok.CASE, tok.DEFAULT, tok.SWITCH, tok.FUNCTION): return - return node + raise LintWarning, node class missing_break: 'missing break statement' @@ -332,7 +332,7 @@ return if None in _get_exit_points(case_contents): # Show the warning on the *next* node. - return node.parent.kids[node.node_index+1] + raise LintWarning, node.parent.kids[node.node_index+1] class missing_break_for_last_case: 'missing break statement for last case in switch' @@ -343,18 +343,18 @@ case_contents = node.kids[1] assert case_contents.kind == tok.LC if None in _get_exit_points(case_contents): - return node + raise LintWarning, node class multiple_plus_minus: 'unknown order of operations for successive plus (e.g. x+++y) or minus (e.g. x---y) signs' @onpush(tok.INC) def _inc(self, node): if node.node_index == 0 and node.parent.kind == tok.PLUS: - return node + raise LintWarning, node @onpush(tok.DEC) def _dec(self, node): if node.node_index == 0 and node.parent.kind == tok.MINUS: - return node + raise LintWarning, node class useless_assign: 'useless assignment' @@ -366,7 +366,7 @@ elif node.parent.kind == tok.VAR: value = node.kids[0] if value and value.kind == tok.NAME and node.atom == value.atom: - return node + raise LintWarning, node class unreachable_code: 'unreachable code' @@ -374,7 +374,7 @@ def _lint(self, node): if node.parent.kind == tok.LC and \ node.node_index != len(node.parent.kids)-1: - return node.parent.kids[node.node_index+1] + raise LintWarning, node.parent.kids[node.node_index+1] class meaningless_block: 'meaningless block; curly braces have no impact' @@ -382,45 +382,45 @@ def _lint(self, node): condition, if_, else_ = node.kids if condition.kind == tok.PRIMARY and condition.opcode in (op.TRUE, op.FALSE, op.NULL): - return condition + raise LintWarning, condition #TODO: @onpush(tok.WHILE) def _lint(self, node): condition = node.kids[0] if condition.kind == tok.PRIMARY and condition.opcode in (op.FALSE, op.NULL): - return condition + raise LintWarning, condition @onpush(tok.LC) def _lint(self, node): if node.parent and node.parent.kind == tok.LC: - return node + raise LintWarning, node class useless_void: 'use of the void type may be unnecessary (void is always undefined)' @onpush((tok.UNARYOP, op.VOID)) def _lint(self, node): - return node + raise LintWarning, node class parseint_missing_radix: 'parseInt missing radix parameter' @onpush((tok.LP, op.CALL)) def _lint(self, node): if node.kids[0].kind == tok.NAME and node.kids[0].atom == 'parseInt' and len(node.kids) <= 2: - return node + raise LintWarning, node class leading_decimal_point: 'leading decimal point may indicate a number or an object member' @onpush(tok.NUMBER) def _lint(self, node): if node.atom.startswith('.'): - return node + raise LintWarning, node class trailing_decimal_point: 'trailing decimal point may indicate a number or an object member' @onpush(tok.NUMBER) def _lint(self, node): if node.parent.kind == tok.DOT: - return node + raise LintWarning, node if node.atom.endswith('.'): - return node + raise LintWarning, node class octal_number: 'leading zeros make an octal number' @@ -428,21 +428,21 @@ @onpush(tok.NUMBER) def _line(self, node): if self._regexp.match(node.atom): - return node + raise LintWarning, node class trailing_comma_in_array: 'extra comma is not recommended in array initializers' @onpush(tok.RB) def _line(self, node): if node.end_comma: - return node + raise LintWarning, node class useless_quotes: 'the quotation marks are unnecessary' @onpush(tok.STRING) def _lint(self, node): if node.node_index == 0 and node.parent.kind == tok.COLON: - return node + raise LintWarning, node class mismatch_ctrl_comments: 'mismatched control comment; "ignore" and "end" control comments must have a one-to-one correspondence' This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <mat...@us...> - 2008-04-25 22:24:52
|
Revision: 195 http://javascriptlint.svn.sourceforge.net/javascriptlint/?rev=195&view=rev Author: matthiasmiller Date: 2008-04-25 15:24:51 -0700 (Fri, 25 Apr 2008) Log Message: ----------- Change scope checks to use visitors. Modified Paths: -------------- trunk/pyjsl/lint.py trunk/pyjsl/visitation.py Modified: trunk/pyjsl/lint.py =================================================================== --- trunk/pyjsl/lint.py 2008-04-25 21:52:35 UTC (rev 194) +++ trunk/pyjsl/lint.py 2008-04-25 22:24:51 UTC (rev 195) @@ -217,14 +217,22 @@ for pos, msg in parse_errors: _report(pos, msg, False) - visitors = visitation.make_visitors(warnings.klasses)['push'] + # Find all visitors and convert them into "onpush" callbacks that call "report" + visitors = {} + visitation.make_visitors(visitors, warnings.klasses) + for event in visitors: + for kind, callbacks in visitors[event].items(): + visitors[event][kind] = [_getreporter(callback, report) for callback in callbacks] assert not script_cache imports = script_cache['imports'] = set() scope = script_cache['scope'] = Scope(root) + # Push the scope/variable checks. + visitation.make_visitors(visitors, [_get_scope_checks(scope, report)]) + # kickoff! - _lint_node(root, visitors, report, scope) + _lint_node(root, visitors) # Process imports by copying global declarations into the universal scope. imports |= set(conf['declarations']) @@ -245,6 +253,15 @@ if not node.atom in imports: report(node, 'undeclared_identifier') +def _getreporter(visitor, report): + def onpush(node): + try: + ret = visitor(node) + assert ret is None, 'visitor should raise an exception, not return a value' + except warnings.LintWarning, warning: + report(warning.node, visitor.im_class.__name__) + return onpush + def _warn_or_declare(scope, name, node, report): other = scope.get_identifier(name) if other and other.kind == tok.FUNCTION and name in other.fn_args: @@ -254,42 +271,58 @@ else: scope.add_declaration(name, node) -def _lint_node(node, visitors, report, scope): +def _get_scope_checks(scope, report): + scopes = [scope] - # Let the visitors warn. - for kind in (node.kind, (node.kind, node.opcode)): - if kind in visitors: - for visitor in visitors[kind]: - try: - ret = visitor(node) - assert ret is None, 'visitor should raise an exception, not return a value' - except warnings.LintWarning, warning: - report(warning.node, visitor.im_class.__name__) + class scope_checks: + ' ' + @visitation.visit('push', tok.NAME) + def _name(self, node): + if node.node_index == 0 and node.parent.kind == tok.COLON and node.parent.parent.kind == tok.RC: + pass # left side of object literal + elif node.parent.kind == tok.CATCH: + scopes[-1].add_declaration(node.atom, node) + else: + scopes[-1].add_reference(node.atom, node) - if node.kind == tok.NAME: - if node.node_index == 0 and node.parent.kind == tok.COLON and node.parent.parent.kind == tok.RC: - pass # left side of object literal - elif node.parent.kind == tok.CATCH: - scope.add_declaration(node.atom, node) - else: - scope.add_reference(node.atom, node) + @visitation.visit('push', tok.FUNCTION) + def _push_func(self, node): + if node.fn_name: + _warn_or_declare(scopes[-1], node.fn_name, node, report) + self._push_scope(node) + for var_name in node.fn_args: + scopes[-1].add_declaration(var_name, node) - # Push function identifiers - if node.kind == tok.FUNCTION: - if node.fn_name: - _warn_or_declare(scope, node.fn_name, node, report) - scope = scope.add_scope(node) - for var_name in node.fn_args: - scope.add_declaration(var_name, node) - elif node.kind == tok.LEXICALSCOPE: - scope = scope.add_scope(node) - elif node.kind == tok.WITH: - scope = scope.add_scope(node) + @visitation.visit('push', tok.LEXICALSCOPE, tok.WITH) + def _push_scope(self, node): + scopes.append(scopes[-1].add_scope(node)) - if node.parent and node.parent.kind == tok.VAR: - _warn_or_declare(scope, node.atom, node, report) + @visitation.visit('pop', tok.FUNCTION, tok.LEXICALSCOPE, tok.WITH) + def _pop_scope(self, node): + scopes.pop() + @visitation.visit('push', tok.VAR) + def _push_var(self, node): + for kid in node.kids: + _warn_or_declare(scope, kid.atom, node, report) + + return scope_checks + + +def _lint_node(node, visitors): + + for kind in (node.kind, (node.kind, node.opcode)): + if kind in visitors['push']: + for visitor in visitors['push'][kind]: + visitor(node) + for child in node.kids: if child: - _lint_node(child, visitors, report, scope) + _lint_node(child, visitors) + for kind in (node.kind, (node.kind, node.opcode)): + if kind in visitors['pop']: + for visitor in visitors['pop'][kind]: + visitor(node) + + Modified: trunk/pyjsl/visitation.py =================================================================== --- trunk/pyjsl/visitation.py 2008-04-25 21:52:35 UTC (rev 194) +++ trunk/pyjsl/visitation.py 2008-04-25 22:24:51 UTC (rev 195) @@ -10,13 +10,21 @@ def _decorate(fn): fn._visit_event = event fn._visit_nodes = args + print dir(fn), fn.func_name + raise ValueError return fn return _decorate -def make_visitors(klasses): +def make_visitors(visitors, klasses): """ Searches klasses for all member functions decorated with @visit and - returns a dictionary that maps from node type to visitor function. """ - visitors = {} + fills a dictionary that looks like: + visitors = { + 'event_name': { + 'node_type' : [func1, func2] + } + } + """ + assert isinstance(visitors, dict) # Intantiate an instance of each class for klass in klasses: @@ -32,13 +40,15 @@ for node_kind in getattr(func, '_visit_nodes', ()): # Group visitors by event (e.g. push vs pop) if not event_visitors: - if not func._visit_event in visitors: - visitors[func._visit_event] = {} - event_visitors = visitors[func._visit_event] + try: + event_visitors = visitors[func._visit_event] + except KeyError: + event_visitors = visitors[func._visit_event] = {} # Map from node_kind to the function - if not node_kind in visitors: - event_visitors[node_kind] = [] - event_visitors[node_kind].append(func) + try: + event_visitors[node_kind].append(func) + except KeyError: + event_visitors[node_kind] = [func] return visitors This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <mat...@us...> - 2008-04-26 05:09:32
|
Revision: 198 http://javascriptlint.svn.sourceforge.net/javascriptlint/?rev=198&view=rev Author: matthiasmiller Date: 2008-04-25 22:09:30 -0700 (Fri, 25 Apr 2008) Log Message: ----------- Change the visitors to be functions instead of classes. Modified Paths: -------------- trunk/pyjsl/conf.py trunk/pyjsl/lint.py trunk/pyjsl/warnings.py Modified: trunk/pyjsl/conf.py =================================================================== --- trunk/pyjsl/conf.py 2008-04-26 04:40:07 UTC (rev 197) +++ trunk/pyjsl/conf.py 2008-04-26 05:09:30 UTC (rev 198) @@ -68,8 +68,8 @@ 'equal_as_assign': BooleanSetting(True), 'anon_no_return_value': BooleanSetting(True) } - for klass in warnings.klasses: - self._settings[klass.__name__] = BooleanSetting(True) + for name in warnings.warnings: + self._settings[name] = BooleanSetting(True) self.loadline('-block_without_braces') def loadfile(self, path): Modified: trunk/pyjsl/lint.py =================================================================== --- trunk/pyjsl/lint.py 2008-04-26 04:40:07 UTC (rev 197) +++ trunk/pyjsl/lint.py 2008-04-26 05:09:30 UTC (rev 198) @@ -218,8 +218,9 @@ _report(pos, msg, False) # Find all visitors and convert them into "onpush" callbacks that call "report" - visitors = {} - visitation.make_visitors(visitors, warnings.klasses) + visitors = { + 'push': warnings.make_visitors() + } for event in visitors: for kind, callbacks in visitors[event].items(): visitors[event][kind] = [_getreporter(callback, report) for callback in callbacks] @@ -259,7 +260,7 @@ ret = visitor(node) assert ret is None, 'visitor should raise an exception, not return a value' except warnings.LintWarning, warning: - report(warning.node, visitor.im_class.__name__) + report(warning.node, visitor.warning) return onpush def _warn_or_declare(scope, name, node, report): Modified: trunk/pyjsl/warnings.py =================================================================== --- trunk/pyjsl/warnings.py 2008-04-26 04:40:07 UTC (rev 197) +++ trunk/pyjsl/warnings.py 2008-04-26 05:09:30 UTC (rev 198) @@ -1,22 +1,18 @@ # vim: ts=4 sw=4 expandtab """ This module contains all the warnings. To add a new warning, define a -class. Its name should be in lowercase and words should be separated by -underscores. Its docstring should be the warning message. +function. Its name should be in lowercase and words should be separated by +underscores. -The class can have one more more member functions to inspect nodes. The -function should be decorated with a @onpush call specifying the nodes it +The function should be decorated with a @lookfor call specifying the nodes it wants to examine. The node names may be in the tok.KIND or (tok.KIND, op.OPCODE) -format. To report a warning, the function should return the node causing -the warning. +format. To report a warning, the function should raise a LintWarning exception. For example: - class warning_name: - 'questionable JavaScript coding style' - @onpush(tok.NODEKIND, (tok.NODEKIND, op.OPCODE)) - def _lint(self, node): - if questionable: - return node + @lookfor(tok.NODEKIND, (tok.NODEKIND, op.OPCODE)) + def warning_name(node): + if questionable: + raise LintWarning, node """ import re import sys @@ -27,9 +23,59 @@ # TODO: document inspect, node:opcode, etc -def onpush(*args): - return visitation.visit('push', *args) +warnings = { + 'comparison_type_conv': 'comparisons against null, 0, true, false, or an empty string allowing implicit type conversion (use === or !==)', + 'default_not_at_end': 'the default case is not at the end of the switch statement', + 'duplicate_case_in_switch': 'duplicate case in switch statement', + 'missing_default_case': 'missing default case in switch statement', + 'with_statement': 'with statement hides undeclared variables; use temporary variable instead', + 'useless_comparison': 'useless comparison; comparing identical expressions', + 'use_of_label': 'use of label', + 'meaningless_block': 'meaningless block; curly braces have no impact', + 'misplaced_regex': 'regular expressions should be preceded by a left parenthesis, assignment, colon, or comma', + 'assign_to_function_call': 'assignment to a function call', + 'ambiguous_else_stmt': 'the else statement could be matched with one of multiple if statements (use curly braces to indicate intent', + 'block_without_braces': 'block statement without curly braces', + 'ambiguous_nested_stmt': 'block statements containing block statements should use curly braces to resolve ambiguity', + 'inc_dec_within_stmt': 'increment (++) and decrement (--) operators used as part of greater statement', + 'comma_separated_stmts': 'multiple statements separated by commas (use semicolons?)', + 'empty_statement': 'empty statement or extra semicolon', + 'missing_break': 'missing break statement', + 'missing_break_for_last_case': 'missing break statement for last case in switch', + 'multiple_plus_minus': 'unknown order of operations for successive plus (e.g. x+++y) or minus (e.g. x---y) signs', + 'useless_assign': 'useless assignment', + 'unreachable_code': 'unreachable code', + 'meaningless_block': 'meaningless block; curly braces have no impact', + 'useless_void': 'use of the void type may be unnecessary (void is always undefined)', + 'parseint_missing_radix': 'parseInt missing radix parameter', + 'leading_decimal_point': 'leading decimal point may indicate a number or an object member', + 'trailing_decimal_point': 'trailing decimal point may indicate a number or an object member', + 'octal_number': 'leading zeros make an octal number', + 'trailing_comma_in_array': 'extra comma is not recommended in array initializers', + 'useless_quotes': 'the quotation marks are unnecessary', + 'mismatch_ctrl_comments': 'mismatched control comment; "ignore" and "end" control comments must have a one-to-one correspondence', + 'redeclared_var': 'redeclaration of {0} {1}', + 'undeclared_identifier': 'undeclared identifier: {0}', + 'jsl_cc_not_understood': 'couldn\'t understand control comment using /*jsl:keyword*/ syntax', + 'nested_comment': 'nested comment', + 'legacy_cc_not_understood': 'couldn\'t understand control comment using /*@keyword@*/ syntax', + 'var_hides_arg': 'variable {0} hides argument', + 'duplicate_formal': 'TODO', + 'missing_semicolon': 'missing semicolon', + 'ambiguous_newline': 'unexpected end of line; it is ambiguous whether these lines are part of the same statement', + 'missing_option_explicit': 'the "option explicit" control comment is missing', + 'partial_option_explicit': 'the "option explicit" control comment, if used, must be in the first script tag', + 'dup_option_explicit': 'duplicate "option explicit" control comment', +} +def lookfor(*args): + def decorate(fn): + fn._lint_nodes = args + fn.warning = fn.func_name.rstrip('_') + assert fn.warning in warnings, 'Missing warning description: %s' % fn.warning + return fn + return decorate + class LintWarning(Exception): def __init__(self, node): self.node = node @@ -124,382 +170,325 @@ return exit_points -class comparison_type_conv: - 'comparisons against null, 0, true, false, or an empty string allowing implicit type conversion (use === or !==)' - @onpush((tok.EQOP, op.EQ)) - def comparison_type_conv(self, node): - for kid in node.kids: - if kid.kind == tok.PRIMARY and kid.opcode in (op.NULL, op.TRUE, op.FALSE): - continue - if kid.kind == tok.NUMBER and not kid.dval: - continue - if kid.kind == tok.STRING and not kid.atom: - continue - raise LintWarning, kid +@lookfor((tok.EQOP, op.EQ)) +def comparison_type_conv(node): + for kid in node.kids: + if kid.kind == tok.PRIMARY and kid.opcode in (op.NULL, op.TRUE, op.FALSE): + continue + if kid.kind == tok.NUMBER and not kid.dval: + continue + if kid.kind == tok.STRING and not kid.atom: + continue + raise LintWarning, kid -class default_not_at_end: - 'the default case is not at the end of the switch statement' - @onpush(tok.DEFAULT) - def default_not_at_end(self, node): - siblings = node.parent.kids - if node.node_index != len(siblings)-1: - raise LintWarning, siblings[node.node_index+1] +@lookfor(tok.DEFAULT) +def default_not_at_end(node): + siblings = node.parent.kids + if node.node_index != len(siblings)-1: + raise LintWarning, siblings[node.node_index+1] -class duplicate_case_in_switch: - 'duplicate case in switch statement' - @onpush(tok.CASE) - def duplicate_case_in_switch(self, node): - # Only look at previous siblings - siblings = node.parent.kids - siblings = siblings[:node.node_index] - # Compare values (first kid) - node_value = node.kids[0] - for sibling in siblings: - if sibling.kind == tok.CASE: - sibling_value = sibling.kids[0] - if node_value.is_equivalent(sibling_value, True): - raise LintWarning, node +@lookfor(tok.CASE) +def duplicate_case_in_switch(node): + # Only look at previous siblings + siblings = node.parent.kids + siblings = siblings[:node.node_index] + # Compare values (first kid) + node_value = node.kids[0] + for sibling in siblings: + if sibling.kind == tok.CASE: + sibling_value = sibling.kids[0] + if node_value.is_equivalent(sibling_value, True): + raise LintWarning, node -class missing_default_case: - 'missing default case in switch statement' - @onpush(tok.SWITCH) - def missing_default_case(self, node): - value, cases = node.kids - for case in cases.kids: - if case.kind == tok.DEFAULT: - return - raise LintWarning, node +@lookfor(tok.SWITCH) +def missing_default_case(node): + value, cases = node.kids + for case in cases.kids: + if case.kind == tok.DEFAULT: + return + raise LintWarning, node -class with_statement: - 'with statement hides undeclared variables; use temporary variable instead' - @onpush(tok.WITH) - def with_statement(self, node): +@lookfor(tok.WITH) +def with_statement(node): + raise LintWarning, node + +@lookfor(tok.EQOP,tok.RELOP) +def useless_comparison(node): + lvalue, rvalue = node.kids + if lvalue.is_equivalent(rvalue): raise LintWarning, node -class useless_comparison: - 'useless comparison; comparing identical expressions' - @onpush(tok.EQOP,tok.RELOP) - def useless_comparison(self, node): - lvalue, rvalue = node.kids - if lvalue.is_equivalent(rvalue): - raise LintWarning, node +@lookfor((tok.COLON, op.NAME)) +def use_of_label(node): + raise LintWarning, node -class use_of_label: - 'use of label' - @onpush((tok.COLON, op.NAME)) - def use_of_label(self, node): +@lookfor(tok.LC) +def meaningless_block(node): + if node.parent and node.parent.kind == tok.LC: raise LintWarning, node -class meaningless_block: - 'meaningless block; curly braces have no impact' - @onpush(tok.LC) - def meaningless_block(self, node): - if node.parent and node.parent.kind == tok.LC: - raise LintWarning, node +@lookfor((tok.OBJECT, op.REGEXP)) +def misplaced_regex(node): + if node.parent.kind == tok.NAME and node.parent.opcode == op.SETNAME: + return # Allow in var statements + if node.parent.kind == tok.ASSIGN and node.parent.opcode == op.NOP: + return # Allow in assigns + if node.parent.kind == tok.COLON and node.parent.parent.kind == tok.RC: + return # Allow in object literals + if node.parent.kind == tok.LP and node.parent.opcode == op.CALL: + return # Allow in parameters + if node.parent.kind == tok.DOT and node.parent.opcode == op.GETPROP: + return # Allow in /re/.property + if node.parent.kind == tok.RETURN: + return # Allow for return values + raise LintWarning, node -class misplaced_regex: - 'regular expressions should be preceded by a left parenthesis, assignment, colon, or comma' - @onpush((tok.OBJECT, op.REGEXP)) - def misplaced_regex(self, node): - if node.parent.kind == tok.NAME and node.parent.opcode == op.SETNAME: - return # Allow in var statements - if node.parent.kind == tok.ASSIGN and node.parent.opcode == op.NOP: - return # Allow in assigns - if node.parent.kind == tok.COLON and node.parent.parent.kind == tok.RC: - return # Allow in object literals - if node.parent.kind == tok.LP and node.parent.opcode == op.CALL: - return # Allow in parameters - if node.parent.kind == tok.DOT and node.parent.opcode == op.GETPROP: - return # Allow in /re/.property - if node.parent.kind == tok.RETURN: - return # Allow for return values +@lookfor(tok.ASSIGN) +def assign_to_function_call(node): + if node.kids[0].kind == tok.LP: raise LintWarning, node -class assign_to_function_call: - 'assignment to a function call' - @onpush(tok.ASSIGN) - def assign_to_function_call(self, node): - if node.kids[0].kind == tok.LP: - raise LintWarning, node +@lookfor(tok.IF) +def ambiguous_else_stmt(node): + # Only examine this node if it has an else statement. + condition, if_, else_ = node.kids + if not else_: + return -class ambiguous_else_stmt: - 'the else statement could be matched with one of multiple if statements (use curly braces to indicate intent' - @onpush(tok.IF) - def ambiguous_else_stmt(self, node): - # Only examine this node if it has an else statement. - condition, if_, else_ = node.kids - if not else_: + tmp = node + while tmp: + # Curly braces always clarify if statements. + if tmp.kind == tok.LC: return + # Else is only ambiguous in the first branch of an if statement. + if tmp.parent.kind == tok.IF and tmp.node_index == 1: + raise LintWarning, else_ + tmp = tmp.parent - tmp = node - while tmp: - # Curly braces always clarify if statements. - if tmp.kind == tok.LC: - return - # Else is only ambiguous in the first branch of an if statement. - if tmp.parent.kind == tok.IF and tmp.node_index == 1: - raise LintWarning, else_ - tmp = tmp.parent +@lookfor(tok.IF, tok.WHILE, tok.DO, tok.FOR, tok.WITH) +def block_without_braces(node): + if node.kids[1].kind != tok.LC: + raise LintWarning, node.kids[1] -class block_without_braces: - 'block statement without curly braces' - @onpush(tok.IF, tok.WHILE, tok.DO, tok.FOR, tok.WITH) - def block_without_braces(self, node): - if node.kids[1].kind != tok.LC: - raise LintWarning, node.kids[1] +_block_nodes = (tok.IF, tok.WHILE, tok.DO, tok.FOR, tok.WITH) +@lookfor(*_block_nodes) +def ambiguous_nested_stmt(node): + # Ignore "else if" + if node.kind == tok.IF and node.node_index == 2 and node.parent.kind == tok.IF: + return -class ambiguous_nested_stmt: - 'block statements containing block statements should use curly braces to resolve ambiguity' - _block_nodes = (tok.IF, tok.WHILE, tok.DO, tok.FOR, tok.WITH) - @onpush(*_block_nodes) - def ambiguous_nested_stmt(self, node): - # Ignore "else if" - if node.kind == tok.IF and node.node_index == 2 and node.parent.kind == tok.IF: - return + # If the parent is a block, it means a block statement + # was inside a block statement without clarifying curlies. + # (Otherwise, the node type would be tok.LC.) + if node.parent.kind in _block_nodes: + raise LintWarning, node - # If the parent is a block, it means a block statement - # was inside a block statement without clarifying curlies. - # (Otherwise, the node type would be tok.LC.) - if node.parent.kind in self._block_nodes: - raise LintWarning, node +@lookfor(tok.INC, tok.DEC) +def inc_dec_within_stmt(node): + if node.parent.kind == tok.SEMI: + return -class inc_dec_within_stmt: - 'increment (++) and decrement (--) operators used as part of greater statement' - @onpush(tok.INC, tok.DEC) - def inc_dec_within_stmt(self, node): - if node.parent.kind == tok.SEMI: - return + # Allow within the third part of the "for" + tmp = node + while tmp and tmp.parent and tmp.parent.kind == tok.COMMA: + tmp = tmp.parent + if tmp and tmp.node_index == 2 and \ + tmp.parent.kind == tok.RESERVED and \ + tmp.parent.parent.kind == tok.FOR: + return - # Allow within the third part of the "for" - tmp = node - while tmp and tmp.parent and tmp.parent.kind == tok.COMMA: - tmp = tmp.parent - if tmp and tmp.node_index == 2 and \ - tmp.parent.kind == tok.RESERVED and \ - tmp.parent.parent.kind == tok.FOR: - return + raise LintWarning, node +@lookfor(tok.COMMA) +def comma_separated_stmts(node): + # Allow within the first and third part of "for(;;)" + if _get_branch_in_for(node) in (0, 2): + return + # This is an array + if node.parent.kind == tok.RB: + return + raise LintWarning, node + +@lookfor(tok.SEMI) +def empty_statement(node): + if not node.kids[0]: raise LintWarning, node - def _is_for_ternary_stmt(self, node, branch=None): - if node.parent and node.parent.kind == tok.COMMA: - return _is_for_ternary_stmt(node.parent, branch) - return node.node_index == branch and \ - node.parent and \ - node.parent.kind == tok.RESERVED and \ - node.parent.parent.kind == tok.FOR +@lookfor(tok.LC) +def empty_statement_(node): + if node.kids: + return + # Ignore the outermost block. + if not node.parent: + return + # Some empty blocks are meaningful. + if node.parent.kind in (tok.CATCH, tok.CASE, tok.DEFAULT, tok.SWITCH, tok.FUNCTION): + return + raise LintWarning, node -class comma_separated_stmts: - 'multiple statements separated by commas (use semicolons?)' - @onpush(tok.COMMA) - def comma_separated_stmts(self, node): - # Allow within the first and third part of "for(;;)" - if _get_branch_in_for(node) in (0, 2): - return - # This is an array - if node.parent.kind == tok.RB: - return +@lookfor(tok.CASE, tok.DEFAULT) +def missing_break(node): + # The last item is handled separately + if node.node_index == len(node.parent.kids)-1: + return + case_contents = node.kids[1] + assert case_contents.kind == tok.LC + # Ignore empty case statements + if not case_contents.kids: + return + if None in _get_exit_points(case_contents): + # Show the warning on the *next* node. + raise LintWarning, node.parent.kids[node.node_index+1] + +@lookfor(tok.CASE, tok.DEFAULT) +def missing_break_for_last_case(node): + if node.node_index < len(node.parent.kids)-1: + return + case_contents = node.kids[1] + assert case_contents.kind == tok.LC + if None in _get_exit_points(case_contents): raise LintWarning, node -class empty_statement: - 'empty statement or extra semicolon' - @onpush(tok.SEMI) - def empty_statement(self, node): - if not node.kids[0]: - raise LintWarning, node - @onpush(tok.LC) - def empty_statement_(self, node): - if node.kids: - return - # Ignore the outermost block. - if not node.parent: - return - # Some empty blocks are meaningful. - if node.parent.kind in (tok.CATCH, tok.CASE, tok.DEFAULT, tok.SWITCH, tok.FUNCTION): - return +@lookfor(tok.INC) +def multiple_plus_minus(node): + if node.node_index == 0 and node.parent.kind == tok.PLUS: raise LintWarning, node +@lookfor(tok.DEC) +def multiple_plus_minus_(node): + if node.node_index == 0 and node.parent.kind == tok.MINUS: + raise LintWarning, node -class missing_break: - 'missing break statement' - @onpush(tok.CASE, tok.DEFAULT) - def missing_break(self, node): - # The last item is handled separately - if node.node_index == len(node.parent.kids)-1: - return - case_contents = node.kids[1] - assert case_contents.kind == tok.LC - # Ignore empty case statements - if not case_contents.kids: - return - if None in _get_exit_points(case_contents): - # Show the warning on the *next* node. - raise LintWarning, node.parent.kids[node.node_index+1] +@lookfor((tok.NAME, op.SETNAME)) +def useless_assign(node): + if node.parent.kind == tok.ASSIGN: + assert node.node_index == 0 + value = node.parent.kids[1] + elif node.parent.kind == tok.VAR: + value = node.kids[0] + if value and value.kind == tok.NAME and node.atom == value.atom: + raise LintWarning, node -class missing_break_for_last_case: - 'missing break statement for last case in switch' - @onpush(tok.CASE, tok.DEFAULT) - def missing_break_for_last_case(self, node): - if node.node_index < len(node.parent.kids)-1: - return - case_contents = node.kids[1] - assert case_contents.kind == tok.LC - if None in _get_exit_points(case_contents): - raise LintWarning, node +@lookfor(tok.BREAK, tok.CONTINUE, tok.RETURN, tok.THROW) +def unreachable_code(node): + if node.parent.kind == tok.LC and \ + node.node_index != len(node.parent.kids)-1: + raise LintWarning, node.parent.kids[node.node_index+1] -class multiple_plus_minus: - 'unknown order of operations for successive plus (e.g. x+++y) or minus (e.g. x---y) signs' - @onpush(tok.INC) - def multiple_plus_minus(self, node): - if node.node_index == 0 and node.parent.kind == tok.PLUS: - raise LintWarning, node - @onpush(tok.DEC) - def multiple_plus_minus_(self, node): - if node.node_index == 0 and node.parent.kind == tok.MINUS: - raise LintWarning, node +#TODO: @lookfor(tok.IF) +def meaningless_block(node): + condition, if_, else_ = node.kids + if condition.kind == tok.PRIMARY and condition.opcode in (op.TRUE, op.FALSE, op.NULL): + raise LintWarning, condition +#TODO: @lookfor(tok.WHILE) +def meaningless_blocK_(node): + condition = node.kids[0] + if condition.kind == tok.PRIMARY and condition.opcode in (op.FALSE, op.NULL): + raise LintWarning, condition +@lookfor(tok.LC) +def meaningless_block__(node): + if node.parent and node.parent.kind == tok.LC: + raise LintWarning, node -class useless_assign: - 'useless assignment' - @onpush((tok.NAME, op.SETNAME)) - def useless_assign(self, node): - if node.parent.kind == tok.ASSIGN: - assert node.node_index == 0 - value = node.parent.kids[1] - elif node.parent.kind == tok.VAR: - value = node.kids[0] - if value and value.kind == tok.NAME and node.atom == value.atom: - raise LintWarning, node +@lookfor((tok.UNARYOP, op.VOID)) +def useless_void(node): + raise LintWarning, node -class unreachable_code: - 'unreachable code' - @onpush(tok.BREAK, tok.CONTINUE, tok.RETURN, tok.THROW) - def unreachable_code(self, node): - if node.parent.kind == tok.LC and \ - node.node_index != len(node.parent.kids)-1: - raise LintWarning, node.parent.kids[node.node_index+1] +@lookfor((tok.LP, op.CALL)) +def parseint_missing_radix(node): + if node.kids[0].kind == tok.NAME and node.kids[0].atom == 'parseInt' and len(node.kids) <= 2: + raise LintWarning, node -class meaningless_block: - 'meaningless block; curly braces have no impact' - #TODO: @onpush(tok.IF) - def meaningless_block(self, node): - condition, if_, else_ = node.kids - if condition.kind == tok.PRIMARY and condition.opcode in (op.TRUE, op.FALSE, op.NULL): - raise LintWarning, condition - #TODO: @onpush(tok.WHILE) - def meaningless_blocK_(self, node): - condition = node.kids[0] - if condition.kind == tok.PRIMARY and condition.opcode in (op.FALSE, op.NULL): - raise LintWarning, condition - @onpush(tok.LC) - def meaningless_block__(self, node): - if node.parent and node.parent.kind == tok.LC: - raise LintWarning, node +@lookfor(tok.NUMBER) +def leading_decimal_point(node): + if node.atom.startswith('.'): + raise LintWarning, node -class useless_void: - 'use of the void type may be unnecessary (void is always undefined)' - @onpush((tok.UNARYOP, op.VOID)) - def useless_void(self, node): +@lookfor(tok.NUMBER) +def trailing_decimal_point(node): + if node.parent.kind == tok.DOT: raise LintWarning, node + if node.atom.endswith('.'): + raise LintWarning, node -class parseint_missing_radix: - 'parseInt missing radix parameter' - @onpush((tok.LP, op.CALL)) - def parseint_missing_radix(self, node): - if node.kids[0].kind == tok.NAME and node.kids[0].atom == 'parseInt' and len(node.kids) <= 2: - raise LintWarning, node +_octal_regexp = re.compile('^0[0-9]') +@lookfor(tok.NUMBER) +def octal_number(node): + if _octal_regexp.match(node.atom): + raise LintWarning, node -class leading_decimal_point: - 'leading decimal point may indicate a number or an object member' - @onpush(tok.NUMBER) - def leading_decimal_point(self, node): - if node.atom.startswith('.'): - raise LintWarning, node +@lookfor(tok.RB) +def trailing_comma_in_array(node): + if node.end_comma: + raise LintWarning, node -class trailing_decimal_point: - 'trailing decimal point may indicate a number or an object member' - @onpush(tok.NUMBER) - def trailing_decimal_point(self, node): - if node.parent.kind == tok.DOT: - raise LintWarning, node - if node.atom.endswith('.'): - raise LintWarning, node +@lookfor(tok.STRING) +def useless_quotes(node): + if node.node_index == 0 and node.parent.kind == tok.COLON: + raise LintWarning, node -class octal_number: - 'leading zeros make an octal number' - _regexp = re.compile('^0[0-9]') - @onpush(tok.NUMBER) - def octal_number(self, node): - if self._regexp.match(node.atom): - raise LintWarning, node - -class trailing_comma_in_array: - 'extra comma is not recommended in array initializers' - @onpush(tok.RB) - def trailing_comma_in_array(self, node): - if node.end_comma: - raise LintWarning, node - -class useless_quotes: - 'the quotation marks are unnecessary' - @onpush(tok.STRING) - def useless_quotes(self, node): - if node.node_index == 0 and node.parent.kind == tok.COLON: - raise LintWarning, node - -class mismatch_ctrl_comments: - 'mismatched control comment; "ignore" and "end" control comments must have a one-to-one correspondence' +@lookfor() +def mismatch_ctrl_comments(node): pass -class redeclared_var: - 'redeclaration of {0} {1}' +@lookfor() +def redeclared_var(node): pass -class undeclared_identifier: - 'undeclared identifier: {0}' +@lookfor() +def undeclared_identifier(node): pass -class jsl_cc_not_understood: - 'couldn\'t understand control comment using /*jsl:keyword*/ syntax' +@lookfor() +def jsl_cc_not_understood(node): pass -class nested_comment: - 'nested comment' +@lookfor() +def nested_comment(node): pass -class legacy_cc_not_understood: - 'couldn\'t understand control comment using /*@keyword@*/ syntax' +@lookfor() +def legacy_cc_not_understood(node): pass -class var_hides_arg: - 'variable {0} hides argument' +@lookfor() +def var_hides_arg(node): pass -class duplicate_formal: - 'TODO' +@lookfor() +def duplicate_formal(node): pass -class missing_semicolon: - 'missing semicolon' +@lookfor() +def missing_semicolon(node): pass -class ambiguous_newline: - 'unexpected end of line; it is ambiguous whether these lines are part of the same statement' +@lookfor() +def ambiguous_newline(node): pass -class missing_option_explicit: - 'the "option explicit" control comment is missing' +@lookfor() +def missing_option_explicit(node): pass -class partial_option_explicit: - 'the "option explicit" control comment, if used, must be in the first script tag' +@lookfor() +def partial_option_explicit(node): pass -class dup_option_explicit: - 'duplicate "option explicit" control comment' +@lookfor() +def dup_option_explicit(node): pass -klasses = tuple([ - obj for - obj in - sys.modules[__name__].__dict__.values() if - type(obj) == types.ClassType -]) +def make_visitors(): + functions = [ + obj for obj in sys.modules[__name__].__dict__.values() + if type(obj) == types.FunctionType and hasattr(obj, '_lint_nodes') + ] + visitors = {} + for func in functions: + for node_kind in func._lint_nodes: + try: + visitors[node_kind].append(func) + except KeyError: + visitors[node_kind] = [func] + return visitors + This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |