Merge pull request #79 from subrange/error-span-type

Update inline LLVM doc examples for opaque pointers

Author: ramonasuncion

compiler/CMakeLists.txt

@@ -61,34 +61,34 @@ add_executable(ceramicdoc ${CERAMICDOC_SOURCES})
 add_executable(ut ${UT_SOURCES})
 
 # compiler flags
-target_compile_options(compiler PRIVATE ${LLVM_CXXFLAGS})
-target_compile_options(ceramic     PRIVATE ${LLVM_CXXFLAGS})
-target_compile_options(ceramicdoc  PRIVATE ${LLVM_CXXFLAGS})
-target_compile_options(ut       PRIVATE ${LLVM_CXXFLAGS})
+target_compile_options(compiler   PRIVATE ${LLVM_CXXFLAGS})
+target_compile_options(ceramic    PRIVATE ${LLVM_CXXFLAGS})
+target_compile_options(ceramicdoc PRIVATE ${LLVM_CXXFLAGS})
+target_compile_options(ut         PRIVATE ${LLVM_CXXFLAGS})
 
 # include directories
-target_include_directories(compiler PRIVATE ${LLVM_INCLUDEDIR})
-target_include_directories(ceramic     PRIVATE ${LLVM_INCLUDEDIR})
-target_include_directories(ceramicdoc  PRIVATE ${LLVM_INCLUDEDIR})
-target_include_directories(ut       PRIVATE ${LLVM_INCLUDEDIR})
+target_include_directories(compiler   PRIVATE ${LLVM_INCLUDEDIR})
+target_include_directories(ceramic    PRIVATE ${LLVM_INCLUDEDIR})
+target_include_directories(ceramicdoc PRIVATE ${LLVM_INCLUDEDIR})
+target_include_directories(ut         PRIVATE ${LLVM_INCLUDEDIR})
 
 if(CMAKE_BUILD_TYPE STREQUAL "Debug" OR CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
-    target_compile_definitions(compiler PRIVATE UNDEBUG)
-    target_compile_definitions(ceramic     PRIVATE UNDEBUG)
-    target_compile_definitions(ceramicdoc  PRIVATE UNDEBUG)
-    target_compile_definitions(ut       PRIVATE UNDEBUG)
+    target_compile_definitions(compiler   PRIVATE UNDEBUG)
+    target_compile_definitions(ceramic    PRIVATE UNDEBUG)
+    target_compile_definitions(ceramicdoc PRIVATE UNDEBUG)
+    target_compile_definitions(ut         PRIVATE UNDEBUG)
 else()
-    target_compile_definitions(compiler PRIVATE NDEBUG)
-    target_compile_definitions(ceramic     PRIVATE NDEBUG)
-    target_compile_definitions(ceramicdoc  PRIVATE NDEBUG)
-    target_compile_definitions(ut       PRIVATE NDEBUG)
+    target_compile_definitions(compiler   PRIVATE NDEBUG)
+    target_compile_definitions(ceramic    PRIVATE NDEBUG)
+    target_compile_definitions(ceramicdoc PRIVATE NDEBUG)
+    target_compile_definitions(ut         PRIVATE NDEBUG)
 endif()
 
 if(NOT MSVC)
-    target_compile_options(compiler PRIVATE -fexceptions)
-    target_compile_options(ceramic     PRIVATE -fexceptions)
-    target_compile_options(ceramicdoc  PRIVATE -fexceptions)
-    target_compile_options(ut       PRIVATE -fexceptions)
+    target_compile_options(compiler   PRIVATE -fexceptions)
+    target_compile_options(ceramic    PRIVATE -fexceptions)
+    target_compile_options(ceramicdoc PRIVATE -fexceptions)
+    target_compile_options(ut         PRIVATE -fexceptions)
 endif()
 
 set(ENABLE_PCH False CACHE BOOL
@@ -99,21 +99,21 @@ if(ENABLE_PCH)
 endif(ENABLE_PCH)
 
 if (UNIX)
-    target_link_options(compiler PRIVATE ${LLVM_LDFLAGS})
-    target_link_options(ceramic     PRIVATE ${LLVM_LDFLAGS})
-    target_link_options(ceramicdoc  PRIVATE ${LLVM_LDFLAGS})
-    target_link_options(ut       PRIVATE ${LLVM_LDFLAGS})
+    target_link_options(compiler   PRIVATE ${LLVM_LDFLAGS})
+    target_link_options(ceramic    PRIVATE ${LLVM_LDFLAGS})
+    target_link_options(ceramicdoc PRIVATE ${LLVM_LDFLAGS})
+    target_link_options(ut         PRIVATE ${LLVM_LDFLAGS})
 endif()
 
 # Libraries
-target_link_libraries(ceramic     PRIVATE compiler ${LLVM_LIBS})
-target_link_libraries(ceramicdoc  PRIVATE compiler ${LLVM_LIBS})
-target_link_libraries(ut       PRIVATE compiler ${LLVM_LIBS})
+target_link_libraries(ceramic    PRIVATE compiler ${LLVM_LIBS})
+target_link_libraries(ceramicdoc PRIVATE compiler ${LLVM_LIBS})
+target_link_libraries(ut         PRIVATE compiler ${LLVM_LIBS})
 
 if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
-    target_link_libraries(ceramic     PRIVATE rt dl pthread)
-    target_link_libraries(ceramicdoc  PRIVATE rt dl pthread)
-    target_link_libraries(ut       PRIVATE pthread)
+    target_link_libraries(ceramic    PRIVATE rt dl pthread)
+    target_link_libraries(ceramicdoc PRIVATE rt dl pthread)
+    target_link_libraries(ut         PRIVATE pthread)
 endif()
 
 # Install

compiler/analyzer_op.cpp

@@ -813,14 +813,14 @@ MultiPValuePtr analyzePrimOp(PrimOpPtr x, MultiPValuePtr args) {
         ModulePtr m = staticModule(moduleObj);
         assert(m != nullptr);
 
-        MultiPValuePtr result = new MultiPValue();
+        vector<llvm::StringRef> keys;
+        for (auto const &entry : m->publicGlobals)
+            keys.push_back(entry.getKey());
+        std::sort(keys.begin(), keys.end());
 
-        for (llvm::StringMap<ObjectPtr>::const_iterator
-                 i = m->publicGlobals.begin(),
-                 end = m->publicGlobals.end();
-             i != end; ++i) {
-            result->add(staticPValue(Identifier::get(i->getKey())));
-        }
+        MultiPValuePtr result = new MultiPValue();
+        for (auto const &key : keys)
+            result->add(staticPValue(Identifier::get(key)));
         return result;
     }
 

compiler/externals.cpp

@@ -54,8 +54,10 @@ llvm::FunctionType *ExternalFunction::getLLVMFunctionType() const {
         retType = retInfo.ext.type ? retInfo.ext.type : llvmType(retInfo.type);
     }
 
+    size_t argLimit =
+        isVarArg ? std::min(numReqArg, argInfos.size()) : argInfos.size();
     for (vector<ArgInfo>::const_iterator it = argInfos.begin(),
-                                         ie = argInfos.end();
+                                         ie = argInfos.begin() + (long)argLimit;
          it != ie; ++it) {
         llvm::Type *type;
         if (it->ext.isIndirect()) {

doc/language-reference/compilation.md

@@ -9,7 +9,7 @@ Ceramic uses **whole-program compilation**. Starting from an entry-point source
 
 ### Entry Points
 
-If the entry-point module contains a public symbol named `main`, it is passed to the `callMain` operator function. `callMain` is responsible for calling `main` with its command-line arguments. The instantiated `callMain(static main)` becomes the program's entry point and corresponds to the C ABI `main` symbol.
+If the entry-point module contains a public symbol named `main`, it is passed to the `callMain` operator function. `callMain` is responsible for calling `main` with its command-line arguments. The instantiated `callMain(#main)` becomes the program's entry point and corresponds to the C ABI `main` symbol.
 
 For a `main` entry point, the `setArgcArgv(argc:Int32, argv:Pointer[Pointer[Int8]])` operator function is also instantiated. It is called with the `argc` and `argv` parameters from the C `main` function before `callMain` runs.
 
@@ -38,8 +38,8 @@ define bar;
 
 define pattern;
 [T]
-overload pattern(static T) { println("a"); }
-overload pattern(static bar) { println("b"); }
+overload pattern(#T) { println("a"); }
+overload pattern(#bar) { println("b"); }
 
 testPattern() {
     pattern(foo); // prints a

doc/language-reference/expressions.md

@@ -2,18 +2,18 @@
 
 Ceramic's expression hierarchy, from highest to lowest precedence:
 
-| Level | Forms | Operator functions |
-|-------|-------|--------------------|
-| Atomic | names, literals, `()`, `[]`, `__FILE__` etc., `eval` | (none) |
-| Suffix | `a(b)` `a[b]` `a.0` `a.field` `a^` | `call` `index` `staticIndex` `fieldRef` `dereference` |
-| Prefix | `+a` `-a` `&a` `*a` | `plus` `minus`, address and dispatch are primitive |
-| Multiplicative | `a*b` `a/b` `a%b` | `multiply` `divide` `remainder` |
-| Additive | `a+b` `a-b` | `add` `subtract` |
-| Ordered comparison | `<=` `<` `>` `>=` | `lesserEquals?` `lesser?` `greater?` `greaterEquals?` |
-| Equality | `==` `!=` | `equals?` `notEquals?` |
-| Boolean | `not a` `a and b` `a or b` | primitive, not overloadable |
-| Low-precedence prefix | `if (a) b else c`, `name: a`, `static a`, `..a`, `a -> b` | (none) |
-| Multiple value | `a, b, c` | (none) |
+| Level                 | Forms                                                | Operator functions                                    |
+| --------------------- | ---------------------------------------------------- | ----------------------------------------------------- |
+| Atomic                | names, literals, `()`, `[]`, `__FILE__` etc., `eval` | (none)                                                |
+| Suffix                | `a(b)` `a[b]` `a.0` `a.field` `a^`                   | `call` `index` `staticIndex` `fieldRef` `dereference` |
+| Prefix                | `+a` `-a` `&a` `*a`                                  | `plus` `minus`, address and dispatch are primitive    |
+| Multiplicative        | `a*b` `a/b` `a%b`                                    | `multiply` `divide` `remainder`                       |
+| Additive              | `a+b` `a-b`                                          | `add` `subtract`                                      |
+| Ordered comparison    | `<=` `<` `>` `>=`                                    | `lesserEquals?` `lesser?` `greater?` `greaterEquals?` |
+| Equality              | `==` `!=`                                            | `equals?` `notEquals?`                                |
+| Boolean               | `not a` `a and b` `a or b`                           | primitive, not overloadable                           |
+| Low-precedence prefix | `if (a) b else c`, `name: a`, `#a`, `..a`, `a -> b`  | (none)                                                |
+| Multiple value        | `a, b, c`                                            | (none)                                                |
 
 ### Atomic Expressions
 
@@ -42,14 +42,14 @@ foo(..xs:TT) {
 
 #### Literal Expressions
 
-| Literal | Default type | Type suffix examples |
-|---------|-------------|----------------------|
-| `true` / `false` | `Bool` | (none) |
-| `1`, `0xFF` | `Int32` (or module default) | `ss` `s` `i` `l` `ll` `uss` `us` `u` `ul` `ull` |
-| `1.0`, `1e2` | `Float64` (or module default) | `f` `ff` `fl` `fj` `j` `ffj` `flj` |
-| `'x'` | via `Char` operator | (none) |
-| `"hello"` | via `StringConstant` operator | (none) |
-| `#foo`, `#"foo"` | `Static[#foo]` | (none) |
+| Literal          | Default type                  | Type suffix examples                            |
+| ---------------- | ----------------------------- | ----------------------------------------------- |
+| `true` / `false` | `Bool`                        | (none)                                          |
+| `1`, `0xFF`      | `Int32` (or module default)   | `ss` `s` `i` `l` `ll` `uss` `us` `u` `ul` `ull` |
+| `1.0`, `1e2`     | `Float64` (or module default) | `f` `ff` `fl` `fj` `j` `ffj` `flj`              |
+| `'x'`            | via `Char` operator           | (none)                                          |
+| `"hello"`        | via `StringConstant` operator | (none)                                          |
+| `#foo`, `#"foo"` | `Static[#foo]`                | (none)                                          |
 
 ```ceramic
 println(Type(1));      // Int32
@@ -72,11 +72,11 @@ Integer type suffixes may be applied to floating-point literal tokens to produce
 
 These are only valid inside **alias functions**:
 
-| Operator | Evaluates to |
-|----------|-------------|
-| `__FILE__` | Static string: the source file of the call site |
-| `__LINE__` | `Int32`: the source line |
-| `__COLUMN__` | `Int32`: the source column |
+| Operator       | Evaluates to                                                            |
+| -------------- | ----------------------------------------------------------------------- |
+| `__FILE__`     | Static string: the source file of the call site                         |
+| `__LINE__`     | `Int32`: the source line                                                |
+| `__COLUMN__`   | `Int32`: the source column                                              |
 | `__ARG__ name` | Static string. Textual representation of argument `name`, not evaluated |
 
 ```ceramic
@@ -156,12 +156,12 @@ Desugars to `dereference(a)`. Used to get a reference to the value behind a poin
 
 ### Prefix Operators
 
-| Operator | Behavior |
-|----------|----------|
-| `+a` | desugars to `plus(a)` |
-| `-a` | desugars to `minus(a)` |
-| `&a` | primitive: returns `Pointer[T]` to `a`, which must be an lvalue. Not overloadable |
-| `*a` | dispatch operator. Only valid as an argument to a call expression |
+| Operator | Behavior                                                                          |
+| -------- | --------------------------------------------------------------------------------- |
+| `+a`     | desugars to `plus(a)`                                                             |
+| `-a`     | desugars to `minus(a)`                                                            |
+| `&a`     | primitive: returns `Pointer[T]` to `a`, which must be an lvalue. Not overloadable |
+| `*a`     | dispatch operator. Only valid as an argument to a call expression                 |
 
 #### Dispatch (`*a`)
 
@@ -181,36 +181,54 @@ drawShapes(ss:Vector[Shape]) {
 
 ### Arithmetic Operators
 
-| Operator | Desugars to |
-|----------|-------------|
-| `a * b` | `multiply(a, b)` |
-| `a / b` | `divide(a, b)` |
-| `a % b` | `remainder(a, b)` |
-| `a + b` | `add(a, b)` |
-| `a - b` | `subtract(a, b)` |
+| Operator | Desugars to       |
+| -------- | ----------------- |
+| `a * b`  | `multiply(a, b)`  |
+| `a / b`  | `divide(a, b)`    |
+| `a % b`  | `remainder(a, b)` |
+| `a + b`  | `add(a, b)`       |
+| `a - b`  | `subtract(a, b)`  |
 
 All arithmetic operators are left-associative within their precedence group.
 
 ### Comparison Operators
 
-| Operator | Desugars to |
-|----------|-------------|
-| `a <= b` | `lesserEquals?(a, b)` |
-| `a < b` | `lesser?(a, b)` |
-| `a > b` | `greater?(a, b)` |
+| Operator | Desugars to            |
+| -------- | ---------------------- |
+| `a <= b` | `lesserEquals?(a, b)`  |
+| `a < b`  | `lesser?(a, b)`        |
+| `a > b`  | `greater?(a, b)`       |
 | `a >= b` | `greaterEquals?(a, b)` |
-| `a == b` | `equals?(a, b)` |
-| `a != b` | `notEquals?(a, b)` |
+| `a == b` | `equals?(a, b)`        |
+| `a != b` | `notEquals?(a, b)`     |
 
 All comparison operators are left-associative within their precedence group.
 
+### User-Defined Operators
+
+Any sequence of the characters `= ! < > + - * / \ % ~ | &` forms a valid operator token. The sequences `<--`, `-->`, `=>`, `->`, `~>`, and `=` are reserved and cannot be used as operator names.
+
+`a op b` desugars to `infixOperator(a, #op, b)`, which calls `op(a, b)` by default. `op a` desugars to `prefixOperator(#op, a)`, which calls `op(a)` by default. Declare the operator with `define` and provide an implementation with `overload`:
+
+```ceramic
+define (**);
+overload (**)(base:Int32, exp:Int32) : Int32 {
+    var result = 1;
+    for (i in range(exp))
+        result *: base;
+    return result;
+}
+
+println(2 ** 10);  // 1024
+```
+
 ### Boolean Operators
 
-| Operator | Behavior |
-|----------|----------|
-| `not a` | Complement. `a` must be `Bool`. Not overloadable |
-| `a and b` | Short-circuit conjunction. Right-associative |
-| `a or b` | Short-circuit disjunction. Right-associative |
+| Operator  | Behavior                                         |
+| --------- | ------------------------------------------------ |
+| `not a`   | Complement. `a` must be `Bool`. Not overloadable |
+| `a and b` | Short-circuit conjunction. Right-associative     |
+| `a or b`  | Short-circuit disjunction. Right-associative     |
 
 Both `and` and `or` require `Bool` operands and are not overloadable.
 
@@ -229,10 +247,10 @@ Both branches must have the same type. Unlike `if` statements, the `else` clause
 
 #### Static Expressions
 
-`static expr` evaluates `expr` at compile time and wraps the result in `Static[result]`. Used to pass compile-time values to [static arguments](functions.md#static-arguments). Applied to a symbol or static string, it is a no-op.
+`#expr` evaluates `expr` at compile time and wraps the result in `Static[result]`. Used to pass compile-time values to [static arguments](functions.md#static-arguments). Applied to a symbol or static string, it is a no-op.
 
 ```ceramic
-log(static LOG, "starting program");
+log(#LOG, "starting program");
 ```
 
 #### Unpack (`..a`)