Merge branch 'develop'

Author: arshajii

compiler/lang/lang.cpp

@@ -442,13 +442,13 @@ StructType *TryCatch::getExcType(LLVMContext &context) {
 }
 
 GlobalVariable *TryCatch::getTypeIdxVar(Module *module,
-                                        types::Type *catchType) {
+                                        const std::string &name) {
   LLVMContext &context = module->getContext();
   auto *typeInfoType = getTypeInfoType(context);
   const std::string typeVarName =
-      "seq.typeidx." + (catchType ? catchType->getName() : "<all>");
+      "seq.typeidx." + (name.empty() ? "<all>" : name);
   GlobalVariable *tidx = module->getGlobalVariable(typeVarName);
-  int idx = catchType ? catchType->getID() : 0;
+  int idx = types::Type::getID(name);
   if (!tidx)
     tidx = new GlobalVariable(
         *module, typeInfoType, true, GlobalValue::PrivateLinkage,
@@ -459,6 +459,11 @@ GlobalVariable *TryCatch::getTypeIdxVar(Module *module,
   return tidx;
 }
 
+GlobalVariable *TryCatch::getTypeIdxVar(Module *module,
+                                        types::Type *catchType) {
+  return getTypeIdxVar(module, catchType ? catchType->getName() : "");
+}
+
 void TryCatch::resolveTypes() {
   scope->resolveTypes();
   for (auto *block : catchBlocks)
@@ -1352,7 +1357,7 @@ Continue *Continue::clone(Generic *ref) {
   SEQ_RETURN_CLONE(x);
 }
 
-Assert::Assert(Expr *expr) : Stmt("assert"), expr(expr) {}
+Assert::Assert(Expr *expr, Expr *msg) : Stmt("assert"), expr(expr), msg(msg) {}
 
 void Assert::resolveTypes() { expr->resolveTypes(); }
 
@@ -1365,32 +1370,47 @@ void Assert::codegen0(BasicBlock *&block) {
   LLVMContext &context = block->getContext();
   Module *module = block->getModule();
   Function *func = block->getParent();
-
   const bool test = isTest(getBase());
-  auto *assertFail = cast<Function>(module->getOrInsertFunction(
-      test ? "seq_test_failed" : "seq_assert_failed", Type::getVoidTy(context),
-      types::Str->getLLVMType(context), types::Int->getLLVMType(context)));
-  assertFail->setDoesNotThrow();
-  if (!test)
-    assertFail->setDoesNotReturn();
+
   Value *check = expr->codegen(getBase(), block);
   check = expr->getType()->boolValue(check, block, getTryCatch());
-  Value *file = StrExpr(getSrcInfo().file).codegen(getBase(), block);
-  Value *line = IntExpr(getSrcInfo().line).codegen(getBase(), block);
+
+  Value *msgVal = nullptr;
+  if (msg) {
+    msgVal = msg->codegen(getBase(), block);
+    msgVal = msg->getType()->strValue(msgVal, block, getTryCatch());
+  } else {
+    msgVal = StrExpr("").codegen(getBase(), block);
+  }
 
   BasicBlock *fail = BasicBlock::Create(context, "assert_fail", func);
   BasicBlock *pass = BasicBlock::Create(context, "assert_pass", func);
 
   IRBuilder<> builder(block);
   check = builder.CreateTrunc(check, builder.getInt1Ty());
   builder.CreateCondBr(check, pass, fail);
-
   builder.SetInsertPoint(fail);
-  builder.CreateCall(assertFail, {file, line});
-  if (test)
+  if (test) {
+    Function *testFailed = Func::getBuiltin("_test_failed")->getFunc(module);
+    Value *file = StrExpr(getSrcInfo().file).codegen(getBase(), fail);
+    Value *line = IntExpr(getSrcInfo().line).codegen(getBase(), fail);
+    builder.CreateCall(testFailed, {file, line, msgVal});
     builder.CreateBr(pass);
-  else
+  } else {
+    Func *f = Func::getBuiltin("_make_assert_error");
+    Function *assertExc = f->getFunc(module);
+    types::Type *assertErrorType = f->getFuncType()->getBaseType(0);
+
+    Value *excVal = builder.CreateCall(assertExc, msgVal);
+    ValueExpr excArg(assertErrorType, excVal);
+    Throw raise(&excArg);
+    raise.setBase(getBase());
+    raise.setSrcInfo(getSrcInfo());
+    raise.codegen(fail);
+
+    builder.SetInsertPoint(fail);
     builder.CreateUnreachable();
+  }
 
   block = pass;
 }
@@ -1399,7 +1419,7 @@ Assert *Assert::clone(Generic *ref) {
   if (ref->seenClone(this))
     return (Assert *)ref->getClone(this);
 
-  auto *x = new Assert(expr->clone(ref));
+  auto *x = new Assert(expr->clone(ref), msg ? msg->clone(ref) : msg);
   ref->addClone(this, x);
   Stmt::setCloneBase(x, ref);
   SEQ_RETURN_CLONE(x);

compiler/lang/lang.h

@@ -167,6 +167,8 @@ class TryCatch : public Stmt {
   TryCatch *clone(Generic *ref) override;
   static llvm::StructType *getPadType(llvm::LLVMContext &context);
   static llvm::StructType *getExcType(llvm::LLVMContext &context);
+  static llvm::GlobalVariable *getTypeIdxVar(llvm::Module *module,
+                                             const std::string &name);
   static llvm::GlobalVariable *getTypeIdxVar(llvm::Module *module,
                                              types::Type *catchType);
 };
@@ -268,9 +270,10 @@ class Continue : public Stmt {
 class Assert : public Stmt {
 private:
   Expr *expr;
+  Expr *msg;
 
 public:
-  explicit Assert(Expr *expr);
+  explicit Assert(Expr *expr, Expr *msg = nullptr);
   void resolveTypes() override;
   void codegen0(llvm::BasicBlock *&block) override;
   Assert *clone(Generic *ref) override;

compiler/parser/context.h

@@ -126,7 +126,7 @@ struct ImportCache {
 
   std::unordered_map<std::string, std::shared_ptr<Context>> imports;
 
-  ImportCache(const std::string &a = "") : argv0(""), stdlib(nullptr) {}
+  ImportCache(const std::string &a = "") : argv0(a), stdlib(nullptr) {}
   std::string getImportFile(const std::string &what,
                             const std::string &relativeTo,
                             bool forceStdlib = false);

compiler/parser/ocaml.cpp

@@ -449,12 +449,18 @@ unique_ptr<Expr> parse_expr(string code, const seq::SrcInfo &offset) {
 }
 
 unique_ptr<SuiteStmt> parse_file(string file) {
-  ifstream fin(file);
   string result, line;
-  while (getline(fin, line)) {
-    result += line + "\n";
+  if (file == "-") {
+    while (getline(cin, line)) {
+      result += line + "\n";
+    }
+  } else {
+    ifstream fin(file);
+    while (getline(fin, line)) {
+      result += line + "\n";
+    }
+    fin.close();
   }
-  fin.close();
   return parse_code(file, result, 0, 0);
 }
 

compiler/types/types.cpp

@@ -2,6 +2,7 @@
 #include <cstdlib>
 #include <iostream>
 #include <typeinfo>
+#include <unordered_map>
 #include <vector>
 
 using namespace seq;
@@ -12,10 +13,23 @@ types::Type::Type(std::string name, types::Type *parent, bool abstract,
     : name(std::move(name)), parent(parent), abstract(abstract),
       extendable(extendable) {}
 
-int types::Type::getID() const {
-  return (int)std::hash<std::string>()(getName());
+int types::Type::getID(const std::string &name) {
+  static std::unordered_map<std::string, int> cache;
+  static int next = 1000;
+  if (name.empty())
+    return 0;
+  auto id = cache.find(name);
+  if (id != cache.end()) {
+    return id->second;
+  } else {
+    const int myID = next++;
+    cache[name] = myID;
+    return myID;
+  }
 }
 
+int types::Type::getID() const { return getID(getName()); }
+
 std::string types::Type::getName() const {
   std::string nameFull = name;
   if (numBaseTypes() > 0) {

compiler/types/types.h

@@ -75,6 +75,10 @@ class Type {
   Type(std::string name, Type *parent, bool abstract = false,
        bool extendable = false);
 
+  /// Returns a unique identifier for this type, based on
+  /// the given name.
+  static int getID(const std::string &name);
+
   /// Returns a unique identifier for this type, based on
   /// \ref getName() "getName()".
   virtual int getID() const;

runtime/exc.cpp

@@ -205,6 +205,12 @@ SEQ_FUNC void seq_terminate(void *exc) {
   auto *base = (OurBaseException_t *)((char *)exc + seq_exc_offset());
   void *obj = base->obj;
   auto *hdr = (SeqExcHeader_t *)obj;
+
+  if (std::string(hdr->type.str, hdr->type.len) == "SystemExit") {
+    seq_int_t status = *(seq_int_t *)(hdr + 1);
+    exit((int)status);
+  }
+
   fprintf(stderr, "\033[1m");
   fwrite(hdr->type.str, 1, (size_t)hdr->type.len, stderr);
   if (hdr->msg.len > 0) {

runtime/lib.cpp

@@ -68,15 +68,6 @@ SEQ_FUNC seq_int_t seq_time_monotonic() {
   return nanos;
 }
 
-SEQ_FUNC void seq_assert_failed(seq_str_t file, seq_int_t line) {
-  fprintf(stderr, "assertion failed on line %d (%s)\n", (int)line, file.str);
-  exit(EXIT_FAILURE);
-}
-
-SEQ_FUNC void seq_test_failed(seq_str_t file, seq_int_t line) {
-  printf("\033[1;31mTEST FAILED:\033[0m %s (line %d)\n", file.str, (int)line);
-}
-
 extern char **environ;
 SEQ_FUNC char **seq_env() { return environ; }
 

stdlib/core/err.seq

@@ -162,7 +162,63 @@ class StopIteration:
     def message(self: StopIteration):
         return self._hdr.msg
 
+class AssertionError:
+    _hdr: ExcHeader
+
+    def __init__(self: AssertionError):
+        self._hdr = ('AssertionError', '', '', '', 0, 0)
+
+    def __init__(self: AssertionError, message: str):
+        self._hdr = ('AssertionError', message, '', '', 0, 0)
+
+    @property
+    def message(self: AssertionError):
+        return self._hdr.msg
+
+class SystemExit:
+    _hdr: ExcHeader
+    _status: int
+
+    def __init__(self: SystemExit):
+        self._hdr = ('SystemExit', '', '', '', 0, 0)
+        self._status = 0
+
+    def __init__(self: SystemExit, status: int):
+        self._hdr = ('SystemExit', '', '', '', 0, 0)
+        self._status = status
+
+    def __init__(self: SystemExit, message: str):
+        self._hdr = ('SystemExit', message, '', '', 0, 0)
+        self._status = 0
+
+    def __init__(self: SystemExit, message: str, status: int):
+        self._hdr = ('SystemExit', message, '', '', 0, 0)
+        self._status = status
+
+    @property
+    def message(self: SystemExit):
+        return self._hdr.msg
+
+    @property
+    def status(self: SystemExit):
+        return self._status
+
 def check_errno(prefix: str):
     msg = _C.seq_check_errno()
     if msg:
         raise OSError(prefix + msg)
+
+@builtin
+def _make_assert_error(msg: str) -> AssertionError:
+    return AssertionError(msg)
+
+@builtin
+def _test_failed(file: str, line: int, msg: str):
+    s = "\033[1;31mTEST FAILED:\033[0m " + file + " (line " + str(line) + ")"
+    if msg:
+        s += ": " + msg
+    print s
+
+@builtin
+def _handle_exit(e: SystemExit):
+    _C.exit(e.status)

stdlib/core/sort.seq

@@ -9,7 +9,7 @@ def sorted[S,T](
     v: generator[T],
     key: optional[function[S,T]] = None,
     algorithm: optional[str] = None,
-    reversed: bool = False
+    reverse: bool = False
 ):
     """
     sorted(v)
@@ -19,14 +19,14 @@ def sorted[S,T](
     newlist = [a for a in v]
     if key:
         if algorithm:
-            newlist.sort(~key, ~algorithm, reversed)
+            newlist.sort(~key, ~algorithm, reverse)
         else:
-            newlist.sort(~key, None, reversed)
+            newlist.sort(~key, None, reverse)
     else:
         if algorithm:
-            newlist.sort(None, ~algorithm, reversed)
+            newlist.sort(None, ~algorithm, reverse)
         else:
-            newlist.sort(None, None, reversed)
+            newlist.sort(None, None, reverse)
     return newlist
 
 def _sort_list[T,S](self: list[T], key: function[S,T], algorithm: str):
@@ -49,7 +49,7 @@ extend list[T]:
         self: list[T],
         key: optional[function[S,T]] = None,
         algorithm: optional[str] = None,
-        reversed: bool = False
+        reverse: bool = False
     ):
         def ident[T](x: T):
             return x
@@ -59,7 +59,5 @@ extend list[T]:
             _sort_list(self, ~key, alg)
         else:
             _sort_list(self, ident[T], alg)
-        if reversed:
+        if reverse:
             self.reverse()
-
-

stdlib/sys.seq

@@ -4,4 +4,5 @@ stdin = File(_C.seq_stdin())
 stdout = File(_C.seq_stdout())
 stderr = File(_C.seq_stderr())
 
-exit = _C.exit
+def exit(status: int = 0):
+    raise SystemExit(status)

stdlib/threading.seq

@@ -42,9 +42,3 @@ def get_native_id():
 
 def get_ident():
     return get_native_id() + 1
-
-extend list[T]:
-    def lock_append(self: list[T], it: T, lock: Lock):
-        with lock:
-            self.append(it)
-

test/core/sort.seq

@@ -110,8 +110,8 @@ def test_stable():
     assert tim_sort(data_list, compare_dict) == sorted_list
 
 ### Stdlib sort tests ###
-print_test(sorted(list[int](), compare_less, reversed=True), list[int]()) # EXPECT: []
-print_test(sorted([3, 2, 1], reversed=True), [3, 2, 1]) # EXPECT: [3, 2, 1]
+print_test(sorted(list[int](), compare_less, reverse=True), list[int]()) # EXPECT: []
+print_test(sorted([3, 2, 1], reverse=True), [3, 2, 1]) # EXPECT: [3, 2, 1]
 print_test(sorted([1, 2, 3], compare_greater), [3, 2, 1]) # EXPECT: [3, 2, 1]
-print_test(sorted([1, 2, 3], compare_greater, reversed=True), [1, 2, 3]) # EXPECT: [1, 2, 3]
+print_test(sorted([1, 2, 3], compare_greater, reverse=True), [1, 2, 3]) # EXPECT: [1, 2, 3]