jade-lang 0.2.0 → 0.3.1

data/lib/jade/frontend/type_checking/constraints/deriving/sql_mapper.rb

@@ -0,0 +1,130 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Constraints
+        module Deriving
+          # jade-sql's interface, derived here rather than there: the
+          # deriving framework is not extensible, and this stays inert
+          # without jade-sql, since nothing else names the interface.
+          module SqlMapper
+            extend self
+            include Helpers
+
+            INTERFACE = 'Sql.SqlMapper'
+            ASSIGNMENT = 'Sql.Assignment'
+            ASSIGNMENT_FIELDS = %w[col value_sql params].freeze
+
+            def supports?(interface) = interface == INTERFACE
+
+            def derive(constraint, registry, entry_name, &lookup)
+              return failed(constraint, entry_name) unless assignment_matches?(registry)
+
+              case constraint.type
+              in Type::Application(constructor: Type::Constructor(name:), args: [])
+                Symbol
+                  .type_ref_from_qualified_name(name)
+                  .then { registry.lookup(it) }
+                  .then { derive_for(constraint, it, registry, lookup, entry_name) }
+
+              else
+                failed(constraint, entry_name)
+              end
+            end
+
+            private
+
+            # The interface is matched by name, so some other module called
+            # `Sql` would otherwise be derived against as though it were
+            # jade-sql — building its Assignment with the wrong arity, and
+            # failing at runtime rather than here.
+            def assignment_matches?(registry)
+              Symbol
+                .type_ref_from_qualified_name(ASSIGNMENT)
+                .then { registry.lookup(it) }
+                .then do
+                  it in Symbol::Struct(record_type: { fields: }) and
+                    fields.keys.map(&:to_s) == ASSIGNMENT_FIELDS
+                end
+            end
+
+            def derive_for(constraint, symbol, registry, lookup, entry_name)
+              case symbol
+              in Symbol::Union if single_payload?(symbol, registry)
+                derive_union(constraint, symbol, registry, lookup, entry_name)
+
+              else
+                failed(constraint, entry_name)
+              end
+            end
+
+            # One column per variant, so each variant carries exactly the
+            # value that column is set to.
+            def single_payload?(union_sym, registry)
+              variants(union_sym, registry)
+                .then { it.any? && it.all? { it.args.size == 1 } }
+            end
+
+            def derive_union(constraint, union_sym, registry, lookup, entry_name)
+              vs = variants(union_sym, registry)
+
+              vs
+                .map { encodable_dep(it, registry) }
+                .map { lookup.call(it) }
+                .then { Results.sequence(it) }
+                .map { implementation(constraint, union_body(vs), it) }
+            end
+
+            def encodable_dep(variant, registry)
+              variant
+                .args
+                .first
+                .then { instantiate(it, {}, registry) }
+                .then { Type.constraint('Encode.Encodable', it, nil) }
+            end
+
+            def union_body(variants)
+              variants
+                .each_with_index
+                .map { |v, idx| [[:constructor, v.qualified_name, ['x']], [assignment(v, idx)]] }
+                .then { [:case, [:var, 'f'], it] }
+            end
+
+            def assignment(variant, idx)
+              [:call,
+                [:struct_constructor, ASSIGNMENT, 3],
+                [
+                  wire_name(variant),
+                  '?',
+                  [:list, [[:call, [:impl_arg, idx, 'encoder'], [[:var, 'x']]]]],
+                ],
+              ]
+                .then { [:list, [it]] }
+            end
+
+            def failed(constraint, entry_name)
+              Err[
+                Error::DerivationFailed.new(
+                  entry_name, constraint.origin&.range, constraint:, trace: [],
+                )
+              ]
+            end
+
+            def implementation(constraint, body, deps)
+              Symbol::Implementation.new(
+                module_name: nil,
+                interface: Symbol.type_ref_from_qualified_name(constraint.interface),
+                type: constraint.type,
+                type_params: [],
+                constraints: [],
+                functions: { 'to_assigns' => Symbol::DerivedFunction.new(params: ['f'], body:) },
+                deps:,
+                extends: [],
+                decl_span: nil,
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/constraints/deriving.rb

@@ -2,6 +2,7 @@ require_relative './deriving/helpers.rb'
 require_relative './deriving/eq.rb'
 require_relative './deriving/decodable.rb'
 require_relative './deriving/encodable.rb'
+require_relative './deriving/sql_mapper.rb'
 
 module Jade
   module Frontend
@@ -10,7 +11,7 @@ module Jade
         module Deriving
           extend self
 
-          DERIVERS = [Eq, Decodable, Encodable]
+          DERIVERS = [Eq, Decodable, Encodable, SqlMapper]
 
           def derivable?(interface)
             DERIVERS.any? { it.supports?(interface) }

data/lib/jade/frontend/type_checking/env.rb

@@ -53,6 +53,9 @@ module Jade
             in Placeholder => placeholder
               Scheme[placeholder.free_vars, placeholder.type, placeholder.constraints]
                 .then { Instantiation.instantiate(it, var_gen) }
+
+            in nil
+              fail "no type binding for `#{key}`"
             end
 
           Result.init(type, constraints)

data/lib/jade/frontend/type_checking/generalizer.rb

@@ -14,7 +14,6 @@ module Jade
                 unbound_cs = constraints
                   .map { e.substitution.apply(it) }
                   .uniq
-                  .select { it.unbound_vars.any? }
 
                 Generalization.
                   generalize(

data/lib/jade/frontend/usage_analysis/reference_index.rb

@@ -1,7 +1,11 @@
 module Jade
   module Frontend
     module UsageAnalysis
-      Reference = Data.define(:symbol_key, :kind, :range)
+      # `owner` is the key of the enclosing declaration or implementation,
+      # `nil` only at module level. Declaration owners share the
+      # `symbol_key` namespace, so a reference's owner can be looked up in
+      # the index that produced it.
+      Reference = Data.define(:symbol_key, :kind, :range, :owner)
 
       ReferenceIndex = Data.define(:references) do
         def initialize(references: {})
@@ -41,6 +45,8 @@ module Jade
           case symbol
           in Symbol::Variable
             [:local, symbol.decl_span]
+          in Symbol::Implementation
+            [:impl, symbol.interface.qname, symbol.type.qname]
           in Symbol::ValueRef | Symbol::TypeRef
             [symbol.module_name, symbol.name]
           else

data/lib/jade/frontend/usage_analysis.rb

@@ -15,11 +15,14 @@ module Jade
     #   :type_annotation  - type appearing in a signature, variant args,
     #                       struct fields, interface signatures, etc.
     #   :exposed          - name listed in `module M exposing (...)`
+    #
+    # Every reference also carries the `owner` it was made from — see
+    # ReferenceIndex. Only `:exposed` has none.
     module UsageAnalysis
       extend self
 
       def analyze(entry, _registry)
-        walk(entry.ast, :as_value, entry)
+        walk(entry.ast, :as_value, entry, nil)
           .group_by(&:symbol_key)
           .freeze
           .then { entry.with(usage_index: ReferenceIndex.new(references: it)) }
@@ -27,103 +30,123 @@ module Jade
 
       private
 
-      def walk(node, ctx, entry)
+      # `owner` is the key of the enclosing declaration or implementation,
+      # threaded down rather than recovered afterwards by range
+      # containment: desugared nodes carry `range == nil`, and references
+      # inside an `implements` block sit in no declaration's span, so
+      # both are unbucketable.
+      def walk(node, ctx, entry, owner)
         case node
         in AST::Module(exposing:, body:)
-          walk_exposing(exposing, entry) + walk(body, :as_value, entry)
+          walk_exposing(exposing, entry) + walk(body, :as_value, entry, owner)
 
         in AST::Body(expressions:)
-          expressions.flat_map { walk(it, :as_value, entry) }
+          expressions.flat_map { walk(it, :as_value, entry, owner) }
 
-        in AST::FunctionDeclaration(body:, params:, return_type:)
-          walk(body, :as_value, entry) +
-            params.flat_map { walk_type(it.type, entry) } +
-            walk_type(return_type, entry)
+        in AST::FunctionDeclaration(body:, params:, return_type:, symbol:)
+          ReferenceIndex.key_for(symbol).then do |declared|
+            walk(body, :as_value, entry, declared) +
+              params.flat_map { walk_type(it.type, entry, declared) } +
+              walk_type(return_type, entry, declared)
+          end
 
         in AST::FunctionCall(callee:, args:)
-          walk(callee, :called, entry) + args.flat_map { walk(it, :as_value, entry) }
+          walk(callee, :called, entry, owner) +
+            args.flat_map { walk(it, :as_value, entry, owner) }
 
         in AST::VariableReference(symbol:, range:)
-          ref(symbol, ctx, range)
+          ref(symbol, ctx, range, owner)
 
         in AST::ConstructorReference(symbol:, range:)
-          ref(symbol, ctx == :called ? :constructed : :as_value, range)
+          ref(symbol, ctx == :called ? :constructed : :as_value, range, owner)
 
         in AST::QualifiedAccess(symbol:, range:)
-          ref(symbol, ctx, range)
+          ref(symbol, ctx, range, owner)
 
         in AST::Lambda(body:, params:)
-          walk(body, :as_value, entry) +
-            params.flat_map { walk(it, :as_value, entry) }
+          walk(body, :as_value, entry, owner) +
+            params.flat_map { walk(it, :as_value, entry, owner) }
 
         in AST::Assign(pattern:, expression:)
-          walk(expression, :as_value, entry) + walk(pattern, :as_value, entry)
+          walk(expression, :as_value, entry, owner) +
+            walk(pattern, :as_value, entry, owner)
 
         in AST::IfThenElse(condition:, if_branch:, else_branch:)
-          walk(condition, :as_value, entry) +
-            walk(if_branch, :as_value, entry) +
-            walk(else_branch, :as_value, entry)
+          walk(condition, :as_value, entry, owner) +
+            walk(if_branch, :as_value, entry, owner) +
+            walk(else_branch, :as_value, entry, owner)
 
         in AST::CaseOf(expression:, branches:)
-          walk(expression, :as_value, entry) +
-            branches.flat_map { walk(it, :as_value, entry) }
+          walk(expression, :as_value, entry, owner) +
+            branches.flat_map { walk(it, :as_value, entry, owner) }
 
         in AST::CaseOfBranch(pattern:, body:)
-          walk(pattern, :as_value, entry) + walk(body, :as_value, entry)
+          walk(pattern, :as_value, entry, owner) + walk(body, :as_value, entry, owner)
 
         in AST::Pattern::Constructor(constructor:, patterns:, symbol:)
           # Don't walk `constructor` — it's a bare ConstructorReference
           # and walking it would record a spurious :as_value for every
           # pattern match.
-          ref(symbol, :pattern_match, constructor.range) +
-            patterns.flat_map { walk(it, :as_value, entry) }
+          ref(symbol, :pattern_match, constructor.range, owner) +
+            patterns.flat_map { walk(it, :as_value, entry, owner) }
 
         in AST::Pattern::List(patterns:, rest:)
-          rest_refs = rest ? walk(rest, :as_value, entry) : []
-          patterns.flat_map { walk(it, :as_value, entry) } + rest_refs
+          rest_refs = rest ? walk(rest, :as_value, entry, owner) : []
+          patterns.flat_map { walk(it, :as_value, entry, owner) } + rest_refs
 
         in AST::Pattern::Record(fields:)
-          fields.flat_map { walk(it.pattern, :as_value, entry) }
+          fields.flat_map { walk(it.pattern, :as_value, entry, owner) }
 
         in AST::Pattern::Literal | AST::Pattern::Binding | AST::Pattern::Wildcard
           []
 
         in AST::Grouping(expression:)
-          walk(expression, ctx, entry)
+          walk(expression, ctx, entry, owner)
 
         in AST::List(items:)
-          items.flat_map { walk(it, :as_value, entry) }
+          items.flat_map { walk(it, :as_value, entry, owner) }
 
         in AST::RecordLiteral(fields:)
-          fields.flat_map { walk(it, :as_value, entry) }
+          fields.flat_map { walk(it, :as_value, entry, owner) }
 
         in AST::RecordUpdate(base:, fields:)
-          walk(base, :as_value, entry) + fields.flat_map { walk(it, :as_value, entry) }
+          walk(base, :as_value, entry, owner) +
+            fields.flat_map { walk(it, :as_value, entry, owner) }
 
         in AST::RecordField(value:)
-          walk(value, :as_value, entry)
+          walk(value, :as_value, entry, owner)
 
         in AST::RecordAccess(target:)
-          walk(target, :as_value, entry)
+          walk(target, :as_value, entry, owner)
 
-        in AST::Implementation(applied_type:, functions:)
-          walk_type(applied_type, entry) +
-            functions.flat_map { walk(it, :as_value, entry) }
+        in AST::Implementation(applied_type:, functions:, symbol:)
+          # `implements X with f: <lambda>` has no enclosing declaration,
+          # so the implementation itself owns what its functions call.
+          ReferenceIndex.key_for(symbol).then do |impl|
+            walk_type(applied_type, entry, impl) +
+              functions.flat_map { walk(it, :as_value, entry, impl) }
+          end
 
         in AST::ImplementationFunction(fn:)
-          walk(fn, :as_value, entry)
+          walk(fn, :as_value, entry, owner)
 
-        in AST::TypeDeclaration(variants:)
-          variants.flat_map { it.args.flat_map { walk_type(it, entry) } }
+        in AST::TypeDeclaration(variants:, symbol:)
+          ReferenceIndex.key_for(symbol).then do |declared|
+            variants.flat_map { it.args.flat_map { walk_type(it, entry, declared) } }
+          end
 
-        in AST::StructDeclaration(record_type:)
-          walk_type(record_type, entry)
+        in AST::StructDeclaration(record_type:, symbol:)
+          walk_type(record_type, entry, ReferenceIndex.key_for(symbol))
 
-        in AST::InterfaceDeclaration(functions:)
-          functions.flat_map { walk_type(it.type, entry) }
+        in AST::InterfaceDeclaration(functions:, symbol:)
+          ReferenceIndex.key_for(symbol).then do |declared|
+            functions.flat_map { walk_type(it.type, entry, declared) }
+          end
 
         in AST::InteropImportDeclaration(functions:)
-          functions.flat_map { walk_type(it.type, entry) }
+          # Owned per port, not per `uses` block — the port is what a
+          # caller names and what carries the effect boundary.
+          functions.flat_map { walk_type(it.type, entry, ReferenceIndex.key_for(it.symbol)) }
 
         in AST::ImportDeclaration | AST::VariantDeclaration |
            AST::Literal | AST::CharLiteral |
@@ -136,26 +159,28 @@ module Jade
         end
       end
 
-      def walk_type(node, entry)
+      def walk_type(node, entry, owner)
         case node
         in nil
           []
 
         in AST::TypeName(type:, range:)
           entry.types[type]
-            .then { it ? [Reference[ReferenceIndex.key_for(it), :type_annotation, range]] : [] }
+            .then { it ? ref(it, :type_annotation, range, owner) : [] }
 
         in AST::TypeApplication(constructor:, args:)
-          walk_type(constructor, entry) + args.flat_map { walk_type(it, entry) }
+          walk_type(constructor, entry, owner) +
+            args.flat_map { walk_type(it, entry, owner) }
 
         in AST::TypeFunction(params:, return_type:)
-          params.flat_map { walk_type(it, entry) } + walk_type(return_type, entry)
+          params.flat_map { walk_type(it, entry, owner) } +
+            walk_type(return_type, entry, owner)
 
         in AST::TypeRecord(fields:)
-          fields.values.flat_map { walk_type(it, entry) }
+          fields.values.flat_map { walk_type(it, entry, owner) }
 
         in AST::TypeTuple(items:)
-          items.flat_map { walk_type(it, entry) }
+          items.flat_map { walk_type(it, entry, owner) }
 
         in AST::TypeVar | AST::TypeUnit | AST::QualifiedTypeName |
            AST::TypeParam
@@ -183,12 +208,13 @@ module Jade
         end
       end
 
+      # The exposing list is module level, so these have no owner.
       def exposed_ref(symbol, range)
-        symbol ? [Reference[ReferenceIndex.key_for(symbol), :exposed, range]] : []
+        symbol ? ref(symbol, :exposed, range, nil) : []
       end
 
-      def ref(symbol, kind, range)
-        [Reference[ReferenceIndex.key_for(symbol), kind, range]]
+      def ref(symbol, kind, range, owner)
+        [Reference[ReferenceIndex.key_for(symbol), kind, range, owner]]
       end
     end
   end

data/lib/jade/module_loader.rb

@@ -51,13 +51,37 @@ module Jade
         .modules_in_topo_order
         .reject { Stdlib.is_stdlib?(it) }
         .reduce([registry, {}]) do |(acc, digests), entry|
-          compiled, digest = compile_with_cache(entry, acc, digests, cache_dir, tolerant)
-
-          [acc.update_module(compiled), digests.merge(entry.name => digest)]
+          case broken_dependency(entry, acc)
+          in String => dependency
+            [acc.update_module(blocked(entry, dependency)), digests]
+
+          else
+            compile_with_cache(entry, acc, digests, cache_dir, tolerant)
+              .then { |(compiled, digest)| [acc.update_module(compiled), digests.merge(entry.name => digest)] }
+          end
         end
         .first
     end
 
+    def broken_dependency(entry, registry)
+      direct_deps(entry.name, registry)
+        .filter_map { registry.modules[it] }
+        .find { it.diagnostics.any_errors? }
+        &.name
+    end
+
+    def blocked(entry, dependency)
+      Diagnostics::List
+        .empty
+        .add(
+          Diagnostics::Diagnostic.error(
+            "Not checked: #{dependency} failed to compile",
+            primary: nil,
+          ),
+        )
+        .then { entry.with(diagnostics: it) }
+    end
+
     def compile_with_cache(entry, registry, digests, cache_dir, tolerant)
       return [compile_one(entry, registry, tolerant:), nil] unless cache_dir
 

data/lib/jade/parsing.rb

@@ -362,11 +362,17 @@ module Jade
     parser(:keyed_call_postfix) {
       (
         type(:lparen) >>
-          comma_sequence(record_field) >>
+          comma_sequence(keyed_call_field) >>
           type(:rparen)
       ).map { |(lparen, fields, rparen)| KeyedCallPostfix[lparen, fields, rparen] }
     }
 
+    # Like a record field, but a value may be `_`, so a keyed call can be
+    # partially applied the way a positional one can.
+    parser(:keyed_call_field) {
+      (identifier >> type(:colon).skip >> function_call_arg).map(&AST.record_field)
+    }
+
     parser(:function_call_arg) { placeholder | lazy { expression } }
 
     parser(:placeholder) { type(:wildcard).map(&AST.placeholder) }

data/lib/jade/project.rb

@@ -0,0 +1,100 @@
+require 'json'
+require 'pathname'
+
+module Jade
+  # A project's compiler settings, read from `jade.json` at its root.
+  #
+  # Without this, project config only exists as Ruby executed at app boot
+  # (`Jade.setup`), so every tool that runs outside the app — the CLI, an
+  # editor's LSP, a codegen task — is blind to it and has to guess the
+  # source root and which extension gems to load.
+  #
+  # Subclassed rather than `Project = Data.define(...) do ... end` because
+  # constants in that block land in `Jade`, not on the class — which would
+  # put `Jade::DEFAULTS` in the gem's top namespace.
+  class Project < Data.define(
+    :root, :source_roots, :build_dir, :cache_dir, :extensions, :entries, :map
+  )
+    MANIFEST = 'jade.json'.freeze
+
+    DEFAULTS = {
+      source_roots: ['lib'],
+      build_dir: '.jade/build',
+      cache_dir: '.jade/cache',
+      extensions: [],
+      entries: [],
+      map: {},
+    }.freeze
+
+    class NotFound < StandardError
+      def initialize(from)
+        super(<<~MSG)
+          no #{MANIFEST} in #{from} or any parent directory
+
+          Tools that run outside the app can't see a `Jade.setup` block, so
+          they need the manifest to find your sources and load the gems
+          that ship the modules you import. Write one at the project root:
+
+            { "source_roots": ["lib"], "extensions": ["jade-sql"] }
+        MSG
+      end
+    end
+
+    # nil when there's no manifest — a project predating one is a legitimate
+    # state, not a failure. Callers that need it say so with `find!`.
+    def self.find(from = Dir.pwd)
+      Pathname
+        .new(from)
+        .expand_path
+        .ascend
+        .find { (it + MANIFEST).file? }
+        &.then { load(it) }
+    end
+
+    def self.find!(from = Dir.pwd)
+      find(from) || fail(NotFound.new(from))
+    end
+
+    def self.load(root)
+      (root + MANIFEST)
+        .read
+        .then { JSON.parse(it, symbolize_names: true) }
+        .then { new(root: root.to_s, **DEFAULTS.merge(it)) }
+        .tap { it.require_extensions }
+    end
+
+    def source_root
+      File.expand_path(source_roots.first, root)
+    end
+
+    def build_path
+      File.expand_path(build_dir, root)
+    end
+
+    def cache_path
+      File.expand_path(cache_dir, root)
+    end
+
+    # Modules are addressed relative to the source root, but a path typed at
+    # a shell or sent by an editor is relative to the project root. Accept
+    # either, and say so when it's neither.
+    def source_relative(path)
+      [source_root, root]
+        .map { File.expand_path(path, it) }
+        .find { File.file?(it) }
+        .then { it || fail("no such file: #{path}") }
+        .then { Pathname.new(it).relative_path_from(source_root).to_s }
+    end
+
+    # Extensions register their search root when required, so this is what
+    # lets a standalone tool resolve `Sql.Uuid` to the gem that ships it.
+    #
+    # Plain `require`, not `Kernel.require`: RubyGems overrides the private
+    # instance method and leaves the module function alone, so
+    # `Kernel.require` finds only what is already on the load path — never
+    # an installed gem, which is the whole point here.
+    def require_extensions
+      extensions.each { require(it) }
+    end
+  end
+end

data/lib/jade/source.rb

@@ -1,8 +1,12 @@
 module Jade
-  Source = Data.define(:uri, :text, :line_starts) do
+  # `root` is the directory `uri` is relative to — the app's source root
+  # for its own modules, an extension gem's for the modules it ships. It
+  # is what makes "app or gem?" structural instead of a name list. `nil`
+  # for sources that never came off disk: buffers, stdin, the stdlib.
+  Source = Data.define(:uri, :text, :line_starts, :root) do
     def self.load(source_root, uri, overlays: {})
       text = overlays[uri] || File.read(File.join(source_root, uri))
-      new(uri, text)
+      new(uri:, text:, root: source_root)
     end
 
     def self.load_from_module_name(source_root, name, overlays: {})
@@ -26,7 +30,7 @@ module Jade
       end
     end
 
-    def initialize(uri:, text:, line_starts: calculate_line_starts(text))
+    def initialize(uri:, text:, line_starts: calculate_line_starts(text), root: nil)
       super
     end
 

data/lib/jade/stdlib/decode.rb

@@ -182,6 +182,24 @@ module Jade
         Jade::Decode::Decoder[Jade::Decode::Desc::Fail[msg]]
       }
 
+      # Backs derived Decodable for unions whose variants take no
+      # arguments. `names` and `values` are positionally paired.
+      function(
+        'string_enum',
+        { names: 'List(String)', values: 'List(a)' },
+        'Decoder(a)',
+      ) { |names, values|
+        table = names.zip(values).to_h
+
+        ->(s) {
+          table.key?(s) \
+            ? Jade::Decode::Decoder[Jade::Decode::Desc::Succeed[table[s]]]
+            : Jade::Decode::Decoder[Jade::Decode::Desc::Fail["expected one of #{names.join(', ')}, got #{s.inspect}"]]
+        }
+          .then { Jade::Decode::Desc::AndThen[it, Jade::Decode::Desc::Str[]] }
+          .then { Jade::Decode::Decoder[it] }
+      }
+
       function(
         'from_result',
         { r: 'Result(a, String)' },

data/lib/jade/type.rb

@@ -168,12 +168,15 @@ module Jade
           end
 
         interface = registry.lookup(symbol.interface)
+
+        # Keep the map the type param lands in: the return type has to see
+        # the same variable, or the constraint ends up on a variable that
+        # appears in no type and nothing can ever bind it.
+        param_type, _, local_map =
+          from_symbol_r(interface.type_param, registry, var_gen, local_map)
+
         constraint = Type
-          .constraint(
-            symbol.interface.qualified_name,
-            from_symbol_r(interface.type_param, registry, var_gen, local_map).first,
-            nil,
-          )
+          .constraint(symbol.interface.qualified_name, param_type, nil)
 
         from_symbol_r(symbol.return_type, registry, var_gen, local_map)
           .then { |(t, c, _)| [args.empty? ? t : Type.function(args, t), c + arg_cs + [constraint]] }

data/lib/jade/version.rb

@@ -1,3 +1,3 @@
 module Jade
-  VERSION = '0.2.0'
+  VERSION = '0.3.1'
 end

data/lib/jade.rb

@@ -1,4 +1,5 @@
 require 'jade/version'
+require 'jade/project'
 require 'jade/did_you_mean'
 require 'jade/symbol'
 require 'jade/registry'