[javascriptlint-commit] SF.net SVN: javascriptlint:[365] trunk

[<mat...@us...>]

Revision: 365
          http://sourceforge.net/p/javascriptlint/code/365
Author:   matthiasmiller
Date:     2016-12-23 23:55:18 +0000 (Fri, 23 Dec 2016)
Log Message:
-----------
Use exceptions instead of a callback for parse errors.

Modified Paths:
--------------
    trunk/javascriptlint/jsparse.py
    trunk/javascriptlint/lint.py
    trunk/jsengine/parser/__init__.py

Modified: trunk/javascriptlint/jsparse.py
===================================================================
--- trunk/javascriptlint/jsparse.py	2016-12-23 23:46:55 UTC (rev 364)
+++ trunk/javascriptlint/jsparse.py	2016-12-23 23:55:18 UTC (rev 365)
@@ -4,6 +4,7 @@
 import re
 import unittest
 
+from jsengine import JSSyntaxError
 import jsengine.parser
 from jsengine.parser import kind as tok
 from jsengine.parser import op
@@ -51,15 +52,14 @@
         # this one was within a string or a regexp.
         pos = match.start()+1
 
-def parse(script, jsversion, error_callback, start_offset=0):
+def parse(script, jsversion, start_offset=0):
     """ All node positions will be relative to start_offset. This allows
         scripts to be embedded in a file (for example, HTML).
     """
     assert not start_offset is None
     jsversion = jsversion or JSVersion.default()
     assert isvalidversion(jsversion), jsversion
-    return jsengine.parser.parse(script, jsversion.version,
-                                 error_callback, start_offset)
+    return jsengine.parser.parse(script, jsversion.version, start_offset)
 
 def filtercomments(possible_comments, root_node):
     comment_ignore_ranges = NodeRanges()
@@ -126,15 +126,18 @@
             _dump_node(node, node_positions, depth+1)
 
 def dump_tree(script):
-    def error_callback(line, col, msg, msg_args):
-        print '(%i, %i): %s', (line, col, msg)
-    node = parse(script, None, error_callback)
     node_positions = NodePositions(script)
+    try:
+        node = parse(script, None)
+    except JSSyntaxError, error:
+        pos = node_positions.from_offset(error.offset)
+        print 'Line %i, Column %i: %s' % (pos.line+1, pos.col+1, error.msg)
+        return
     _dump_node(node, node_positions)
 
 class TestComments(unittest.TestCase):
     def _test(self, script, expected_comments):
-        root = parse(script, None, lambda line, col, msg: None)
+        root = parse(script, None)
         comments = findcomments(script, root)
         encountered_comments = [node.atom for node in comments]
         self.assertEquals(encountered_comments, list(expected_comments))
@@ -239,19 +242,18 @@
 class TestLineOffset(unittest.TestCase):
     def testErrorPos(self):
         def geterror(script, start_offset):
-            errors = []
-            def onerror(offset, msg, msg_args):
-                errors.append((offset, msg, msg_args))
-            parse(script, None, onerror, start_offset)
-            self.assertEquals(len(errors), 1)
-            return errors[0]
+            try:
+                parse(script, None, start_offset)
+            except JSSyntaxError, error:
+                return (error.offset, error.msg, error.msg_args)
+            assert False
         self.assertEquals(geterror(' ?', 0), (1, 'syntax_error', {}))
         self.assertEquals(geterror('\n ?', 0), (2, 'syntax_error', {}))
         self.assertEquals(geterror(' ?', 2), (3, 'syntax_error', {}))
         self.assertEquals(geterror('\n ?', 2), (4, 'syntax_error', {}))
     def testNodePos(self):
         def getnodepos(script, start_offset):
-            root = parse(script, None, None, start_offset)
+            root = parse(script, None, start_offset)
             self.assertEquals(root.kind, tok.LC)
             var, = root.kids
             self.assertEquals(var.kind, tok.VAR)
@@ -264,7 +266,7 @@
         self.assertEquals(getnodepos('\n\n var x;', 7), 10)
     def testComments(self):
         def testcomment(comment, startpos, expected_offset):
-            root = parse(comment, None, None, startpos)
+            root = parse(comment, None, startpos)
             comment, = findcomments(comment, root, startpos)
             self.assertEquals(comment.start_offset, expected_offset)
         for comment in ('/*comment*/', '//comment'):

Modified: trunk/javascriptlint/lint.py
===================================================================
--- trunk/javascriptlint/lint.py	2016-12-23 23:46:55 UTC (rev 364)
+++ trunk/javascriptlint/lint.py	2016-12-23 23:55:18 UTC (rev 365)
@@ -351,9 +351,6 @@
 
 def _lint_script_part(script_offset, jsversion, script, script_cache, conf,
                       report_parse_error, report_lint, import_callback):
-    def parse_error(offset, msg, msg_args):
-        parse_errors.append((offset, msg, msg_args))
-
     def report(node, errname, offset=0, **errargs):
         if errname == 'empty_statement' and node.kind == tok.LC:
             for pass_ in passes:
@@ -387,7 +384,6 @@
 
         report_lint(node, errname, offset, **errargs)
 
-    parse_errors = []
     declares = []
     unused_identifiers = []
     import_paths = []
@@ -421,11 +417,11 @@
         report_lint(None, 'e4x_deprecated',
                     jsversionnode.start_offset if jsversionnode else script_offset)
 
-    root = jsparse.parse(script, jsversion, parse_error, script_offset)
-    if not root:
+    try:
+        root = jsparse.parse(script, jsversion, script_offset)
+    except jsparse.JSSyntaxError, error:
         # Report errors and quit.
-        for offset, msg, msg_args in parse_errors:
-            report_parse_error(offset, msg, msg_args)
+        report_parse_error(error.offset, error.msg, error.msg_args)
         return
 
     comments = jsparse.filtercomments(possible_comments, root)
@@ -487,10 +483,6 @@
     if start_ignore:
         report(start_ignore, 'mismatch_ctrl_comments')
 
-    # Wait to report parse errors until loading jsl:ignore directives.
-    for offset, msg in parse_errors:
-        report_parse_error(offset, msg)
-
     # Find all visitors and convert them into "onpush" callbacks that call "report"
     visitors = {
         'push': lintwarnings.make_visitors(conf)

Modified: trunk/jsengine/parser/__init__.py
===================================================================
--- trunk/jsengine/parser/__init__.py	2016-12-23 23:46:55 UTC (rev 364)
+++ trunk/jsengine/parser/__init__.py	2016-12-23 23:55:18 UTC (rev 365)
@@ -814,7 +814,9 @@
     nodes = _sourceelements(t, tok.EOF)
     lc_end_offset = t.expect(tok.EOF).end_offset
     lc_start_offset = nodes[-1].start_offset if nodes else lc_end_offset
-    return ParseNode(kind.LC, None, lc_start_offset, lc_end_offset, None, nodes)
+    root = ParseNode(kind.LC, None, lc_start_offset, lc_end_offset, None, nodes)
+    _validate(root)
+    return root
 
 def is_valid_version(version):
     return version in _VERSIONS
@@ -825,16 +827,10 @@
             assert kid.parent is node
             _validate(kid, depth+1)
 
-def parse(script, jsversion, error_callback, start_offset):
+def parse(script, jsversion, start_offset):
     # TODO: respect version
     assert is_valid_version(jsversion)
-    try:
-        root = parsestring(script, start_offset)
-    except JSSyntaxError as error:
-        error_callback(error.offset, error.msg, error.msg_args)
-        return None
-    _validate(root)
-    return root
+    return parsestring(script, start_offset)
 
 def is_compilable_unit(script, jsversion):
     # TODO: respect version

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.