[RELAY][Errors][WIP] Add descriptive errors for Relay

cmake/modules/ANTLR.cmake

@@ -1,6 +1,6 @@
 if(USE_ANTLR)
-  if(EXISTS /usr/local/lib/antlr-4.7.1-complete.jar)
-    set(ANTLR4 "/usr/local/lib/antlr-4.7.1-complete.jar")
+  if(EXISTS /usr/local/Cellar/antlr/4.7.1_1/antlr-4.7.1-complete.jar)
+    set(ANTLR4 "/usr/local/Cellar/antlr/4.7.1_1/antlr-4.7.1-complete.jar")
 
     set(RELAY_PARSER_DIR
       ${CMAKE_CURRENT_SOURCE_DIR}/python/tvm/relay/grammar)

include/tvm/relay/base.h

@@ -108,7 +108,9 @@ class SourceName : public NodeRef {
    * \brief access the internal node container
    * \return the pointer to the internal node container
    */
-  inline const SourceNameNode* operator->() const;
+  inline const SourceNameNode* operator->() const {
+    return static_cast<SourceNameNode*>(this->node_.get());
+  }
 
   /*!
    * \brief Get an SourceName for a given operator name.

include/tvm/relay/error.h

@@ -8,11 +8,13 @@
 
 #include <string>
 #include "./base.h"
+#include "./source_map.h"
 
 namespace tvm {
 namespace relay {
 
 struct Error : public dmlc::Error {
+  Span sp;
   explicit Error(const std::string &msg) : dmlc::Error(msg) {}
 };
 
@@ -28,6 +30,21 @@ struct TypecheckerError : public Error {
   explicit TypecheckerError(const std::string &msg) : Error(msg) {}
 };
 
+class ErrorReporter {
+public:
+  SourceMap src_map;
+  std::vector<Error> errors;
+
+  ErrorReporter() : src_map(), errors() {}
+  ErrorReporter(SourceMap src_map) : errors() {}
+
+  void Report(const Error& err) {
+    this->errors.push_back(err);
+  }
+
+  dmlc::Error Render();
+};
+
 }  // namespace relay
 }  // namespace tvm
 

include/tvm/relay/module.h

@@ -43,11 +43,16 @@ class ModuleNode : public RelayNode {
   /*! \brief A map from ids to all global functions. */
   tvm::Map<GlobalVar, Function> functions;
 
+  mutable ErrorReporter err_reporter;
+
+  mutable  GlobalVar entry_func;
+
   ModuleNode() {}
 
   void VisitAttrs(tvm::AttrVisitor* v) final {
     v->Visit("functions", &functions);
     v->Visit("global_var_map_", &global_var_map_);
+    v->Visit("entry_func", &entry_func);
   }
 
   TVM_DLL static Module make(tvm::Map<GlobalVar, Function> global_funcs);
@@ -102,6 +107,12 @@ class ModuleNode : public RelayNode {
    */
   void Update(const Module& other);
 
+  /*!
+   * \brief Get the entry point of the module.
+   *
+   */
+  Expr EntryPoint();
+
   static constexpr const char* _type_key = "relay.Module";
   TVM_DECLARE_NODE_TYPE_INFO(ModuleNode, Node);
 

include/tvm/relay/pass.h

@@ -28,6 +28,7 @@ namespace relay {
  * \return A type checked expression with its checked_type field populated.
  */
 Expr InferType(const Expr& expr, const Module& mod);
+
 /*!
  * \brief Infer the type of a function as if it is mapped to var in the mod.
  *

include/tvm/relay/source_map.h

@@ -0,0 +1,46 @@
+/*!
+ *  Copyright (c) 2018 by Contributors
+ * \file source_map.h
+ * \brief A representation of source files and a data structure for
+ * storing them.
+ */
+#ifndef TVM_RELAY_SOURCE_MAP_H_
+#define TVM_RELAY_SOURCE_MAP_H_
+
+#include <tvm/relay/base.h>
+#include <tvm/relay/expr.h>
+#include <string>
+#include <vector>
+
+namespace tvm {
+namespace relay {
+
+struct SourceFragment {
+  SourceName name;
+  std::vector<std::string> source_lines;
+
+  SourceFragment(const SourceName& file_name, const std::string& source);
+
+  SourceFragment(const SourceFragment& sf) {
+    this->name = sf.name;
+    this->source_lines = sf.source_lines;
+  }
+
+  std::vector<std::string> LinesAt(Span sp, int lines);
+};
+
+/*! \brief Maps from FileId's to a SourceFragment.
+ */
+class SourceMap {
+  /*! \brief Map from unique token to a fragment of a source file. */
+  std::unordered_map<SourceName, SourceFragment, NodeHash> map_;
+ public:
+  SourceMap() : map_() {}
+  SourceName AddSource(const std::string& file_name, const std::string& source);
+  SourceName AddSource(const SourceName& source_name, const std::string& source);
+  const SourceFragment & GetSource(SourceName id) const;
+};
+
+}  // namespace relay
+}  // namespace tvm
+#endif  // TVM_RELAY_SOURCE_MAP_H_

python/tvm/relay/_base.py

@@ -0,0 +1,5 @@
+# pylint: disable=no-else-return, unidiomatic-typecheck, undefined-variable
+"""The interface of expr function exposed from C++."""
+from tvm._ffi.function import _init_api
+
+_init_api("relay._base", __name__)

python/tvm/relay/_parser.py

@@ -9,10 +9,12 @@
 from typing import TypeVar, Deque, Tuple, Optional, Union, NamedTuple, List, Callable, Any
 
 from . import module
+from .base import Span, SourceName
 from . import expr
 from . import ty
 from . import op
 
+
 class ParseError(Exception):
     """Exception type for parse errors."""
 
@@ -76,21 +78,35 @@ def lookup(scopes, name):
                 return val
     return None
 
+def spanify(f):
+    def _wrapper(*args, **kwargs):
+        sn = args[0].source_name
+        ctx = args[1]
+        ast = f(*args, **kwargs)
+        line, col = ctx.getSourceInterval()
+        sp = Span(sn, line, col)
+        ast.set_span(sp)
+        return ast
+    return _wrapper
+
 # TODO(@jmp): Use https://stackoverflow.com/q/13889941
 # to figure out how to get ANTLR4 to be more unhappy about syntax errors
 class ParseTreeToRelayIR(RelayVisitor):
     """Parse Relay text format into Relay IR."""
 
-    def __init__(self):
+    def __init__(self, source_name):
         # type: () -> None
+        self.source_name = source_name
         self.module = module.Module({})   # type: module.Module
 
         # Adding an empty scope allows naked lets without pain.
         self.var_scopes = deque([deque()]) # type: Scopes[expr.Var]
         self.type_param_scopes = deque([deque()]) # type: Scopes[ty.TypeVar]
+        self.graph_expr = []
 
         super(ParseTreeToRelayIR, self).__init__()
 
+
     def enter_var_scope(self):
         # type: () -> None
         """Enter a new Var scope so it can be popped off later."""
@@ -131,6 +147,20 @@ def mk_typ(self, name, kind):
         self.type_param_scopes[0].appendleft((name, typ))
         return typ
 
+    def local_lookup(self, name):
+        try:
+            graph_nid = int(name)
+            return self.graph_expr[graph_nid]
+        except ValueError:
+            var = lookup(self.var_scopes, name)
+
+            if var is None:
+                raise ParseError("Couldn't resolve `{}`.".format(name))
+
+            return var
+        except IndexError:
+            raise ParseError("Graph Expr error {}".format(name))
+
     def visitTerminal(self, node):
         # type: (TerminalNode) -> Union[expr.Expr, int, float]
         """Visit lexer tokens that aren't ignored or visited by other functions."""
@@ -142,13 +172,8 @@ def visitTerminal(self, node):
         if node_type == RelayLexer.GLOBAL_VAR:
             return expr.GlobalVar(node_text[1:])
         elif node_type == RelayLexer.LOCAL_VAR:
-            name = node_text[1:]
-            var = lookup(self.var_scopes, name)
-            if var is None:
-                raise ParseError("Couldn't resolve `{}`.".format(name))
-
-            return var
-
+            # Remove the leading '%' and lookup the name.
+            return self.local_lookup(node_text[1:])
         # data types
         elif node_type == RelayLexer.INT:
             return int(node_text)
@@ -269,6 +294,7 @@ def visitBinOp(self, ctx):
 
         return relay_op(arg0, arg1)
 
+    @spanify
     def visitVar(self, ctx):
         # type: (RelayParser.VarContext) -> expr.Var
         ident = ctx.ident().LOCAL_VAR()
@@ -304,10 +330,12 @@ def mk_func(self, ctx):
 
         return expr.Function(var_list, body, ret_type, type_params) # type: ignore
 
+    @spanify
     def visitFunc(self, ctx):
         # type: (RelayParser.FuncContext) -> expr.Function
         return self.mk_func(ctx)
 
+    @spanify
     def visitDefn(self, ctx):
         # type: (RelayParser.DefnContext) -> None
         ident = ctx.ident().GLOBAL_VAR()
@@ -317,6 +345,7 @@ def visitDefn(self, ctx):
 
         self.module[ident] = self.mk_func(ctx)
 
+    @spanify
     def visitCall(self, ctx):
         # type: (RelayParser.CallContext) -> expr.Call
         visited_exprs = self.visit_list(ctx.expr())
@@ -326,6 +355,7 @@ def visitCall(self, ctx):
 
         return expr.Call(func, args, None, None)
 
+    @spanify
     def visitIfElse(self, ctx):
         # type: (RelayParser.IfElseContext) -> expr.If
         """Construct a Relay If node. Creates a new scope for each branch."""
@@ -410,6 +440,14 @@ def visitFuncType(self, ctx):
 
         return ty.FuncType(arg_types, ret_type, [], None)
 
+    def visitGraphExpr(self, ctx):
+        graph_nid = int(ctx.LOCAL_VAR().getText()[1:])
+        value = self.visit(ctx.expr(0))
+        assert graph_nid == len(self.graph_expr)
+        self.graph_expr.append(value)
+        kont = self.visit(ctx.expr(1))
+        return kont
+
 def make_parser(data):
     # type: (str) -> RelayParser
     """Construct a RelayParser a given data stream."""
@@ -418,8 +456,20 @@ def make_parser(data):
     token_stream = CommonTokenStream(lexer)
     return RelayParser(token_stream)
 
-def fromtext(data):
-    # type: (str) -> Union[expr.Expr, env.Environment]
+__source_name_counter__ = 0
+
+def fromtext(data, source_name=None):
+    # type: (str, str) -> Union[expr.Expr, env.Environment]
     """Parse a Relay program."""
+    global __source_name_counter__
+
+    if source_name is None:
+        source_name = "source_file{0}".format(__source_name_counter__)
+
+    if isinstance(source_name, str):
+        source_name = SourceName(source_name)
+
+    import pdb; pdb.set_trace()
+    print(data)
     tree = make_parser(data).prog()
-    return ParseTreeToRelayIR().visit(tree)
+    return ParseTreeToRelayIR(source_name).visit(tree)

python/tvm/relay/base.py

@@ -4,6 +4,7 @@
 from .._ffi.node import NodeBase, register_node as _register_tvm_node
 from . import _make
 from . import _expr
+from . import _base
 
 NodeBase = NodeBase
 
@@ -63,6 +64,9 @@ def astext(self, show_meta_data=True, annotate=None):
         """
         return _expr.RelayPrint(self, show_meta_data, annotate)
 
+    def set_span(self, span):
+        _base.set_span(self, span)
+
 
 @register_relay_node
 class Span(RelayNode):
@@ -71,6 +75,12 @@ class Span(RelayNode):
     def __init__(self, source, lineno, col_offset):
         self.__init_handle_by_constructor__(_make.Span, source, lineno, col_offset)
 
+@register_relay_node
+class SourceName(RelayNode):
+    """A identifier for a source location"""
+
+    def __init__(self, name):
+        self.__init_handle_by_constructor__(_make.SourceName, name)
 
 @register_relay_node
 class Id(NodeBase):

python/tvm/relay/grammar/Relay.g4

@@ -20,7 +20,7 @@ NE: '!=' ;
 
 opIdent: CNAME ;
 GLOBAL_VAR: '@' CNAME ;
-LOCAL_VAR: '%' CNAME ;
+LOCAL_VAR: '%' (CNAME | INT);
 
 MUT: 'mut' ;
 
@@ -83,8 +83,9 @@ expr
 
   | ident                                     # identExpr
   | scalar                                    # scalarExpr
-  // | expr '.' INT                              # project
-  // | 'debug'                                   # debug
+  | LOCAL_VAR '=' expr ';' expr               # graphExpr
+  // | expr '.' INT                           # project
+  // | 'debug'                                # debug
   ;
 
 func: 'fn'        varList ('->' type_)? body ;
@@ -131,7 +132,7 @@ identType: CNAME ;
 // Float16, Float32, Float64
 // Bool
 
-body: '{' expr '}' ;
+body: '{' expr ';' '}' ;
 
 scalar
   : FLOAT    # scalarFloat

python/tvm/relay/parser.py

@@ -1,5 +1,6 @@
 """A parser for Relay's text format."""
 from __future__ import absolute_import
+from .. import register_func
 
 def enabled():
     """Is the parser enabled/Can we import the parser?"""
@@ -11,7 +12,8 @@ def enabled():
     except Exception:
         return False
 
-def fromtext(data):
+@register_func("relay.fromtext")
+def fromtext(data, source_name=None):
     """Parse a Relay program."""
     from tvm.relay import _parser
-    return _parser.fromtext(data)
+    return _parser.fromtext(data, source_name)