carbon-core 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d19855dccc09339b3aab63ae8189dd7d2c8be42d
-  data.tar.gz: e83a47d93719cea99bc46e972ee5cc2be8d23ab9
+  metadata.gz: 8365acf735d2c50dee428d024b4a840c1c6161e7
+  data.tar.gz: 279f5819696b66cd4e7add773d8afc8a75409ea7
 SHA512:
-  metadata.gz: d167ad893b767cbe85fbece99c690f71b824c3847070122c162bb64559ccbc567ebd4c7ebdb4596c3a211f069cfe14caf8e60428f328736c2eaae631ebd5a1b0
-  data.tar.gz: d01280b2758d932ded3fb9399f009fbaa968ae115cbf69b415a2aaadb59926f809f96105cf876fbec474aa131ed814a5cc7d6fdccb1e1dc748b02fc936257bde
+  metadata.gz: 0b429250034abeca6ee48306e4ce461cfc432ac622f6ef0471c8efa7c9e40baa5016559672660258ea90fcd93f92d7ccfe39d852a9fefb34b3dc9b4ffaa6aa4a
+  data.tar.gz: 3e9e619482e2303cc9643a7c73eb5417982a285986a329b6509e521278b76a6e45c91c32b40b48154625fbc3dabbea38eb56c29c90a9b8747d29f507007964e1

data/.gitattributes

@@ -0,0 +1,17 @@
+# Auto detect text files and perform LF normalization
+* text=auto
+
+# Custom for Visual Studio
+*.cs     diff=csharp
+
+# Standard to msysgit
+*.doc	 diff=astextplain
+*.DOC	 diff=astextplain
+*.docx diff=astextplain
+*.DOCX diff=astextplain
+*.dot  diff=astextplain
+*.DOT  diff=astextplain
+*.pdf  diff=astextplain
+*.PDF	 diff=astextplain
+*.rtf	 diff=astextplain
+*.RTF	 diff=astextplain

data/lib/carbon.rb

@@ -9,6 +9,8 @@ require "concurrent"
 require "llvm"
 require "llvm/core"
 require "carbon/version"
+require "carbon/counter"
+require "carbon/errors"
 
 # Carbon.  The language.
 module Carbon
@@ -37,11 +39,26 @@ module Carbon
   # @param string [::String] The string to hash.
   # @return [::String] The hashed string.
   def self.hash(string)
-    digest = Digest::SHA2.hexdigest(string).hex
+    digest = (Digest::SHA2.hexdigest(string).hex << 6) ^ 0xCA5B04
     encoded = Base58.encode(digest)
     encoded.scan(/.{1,9}/).join("-").freeze
   end
 
+  # The verboseness of Carbon.  This is a global setting.
+  #
+  # @return [::Integer] The verboseness.
+  def self.verbose
+    @_verbose ||= 1
+  end
+
+  # The verboseness of Carbon.  This is a global setting.
+  #
+  # @param verbose [::Integer] The new verbose level.
+  # @return [::Integer]
+  def self.verbose=(verbose)
+    @_verbose = verbose
+  end
+
   require "carbon/concrete"
 
   # A Boolean type for Carbon.  This is used as a handy shortcut.
@@ -50,6 +67,13 @@ module Carbon
   # @return [Carbon::Concrete::Type]
   Boolean = Carbon::Type("Carbon::Boolean")
 
+  # A Void type for Carbon.  This is used as a handy shortcut.
+  #
+  # @api private
+  # @return [Carbon::Concrete::Type]
+
+  Void = Carbon::Type("Carbon::Void")
+
   require "carbon/tacky"
   require "carbon/core"
 end

data/lib/carbon/concrete.rb

@@ -14,6 +14,8 @@ module Carbon
   # the things within this module should be serializable, so that libraries
   # may be linked easily back into the process.
   module Concrete
+    OPTIONS = { circular: true, class_cache: true }.freeze
+
     # Loads a dumped object into an instance.  The dumped object should be a
     # Zlib compressed (with Deflate) string.  The dumped object
     # is decompressed and loaded, then passed to {.from}.
@@ -24,7 +26,7 @@ module Carbon
     # @return [::Object] The represented object.
     def self.load(source)
       raw = Zlib::Inflate.inflate(source)
-      Oj.load(raw)
+      Oj.load(raw, OPTIONS)
     end
 
     # Dumps an object to a string.  If the object responds to `#to_basic`, the
@@ -36,7 +38,7 @@ module Carbon
     # @param index [::Object] The object to dump.
     # @return [::String] The dumped object.
     def self.dump(index)
-      raw = Oj.dump(index, circular: true, class_cache: true)
+      raw = Oj.dump(index, OPTIONS)
       Zlib::Deflate.deflate(raw, 9)
     end
   end

data/lib/carbon/concrete/build.rb

@@ -14,24 +14,23 @@ module Carbon
       # corresponding `LLVM::Type`.  This is so that no information is lost
       # when converting the item to the type.
       #
-      # @return [{Concrete::Type => (Concrete::Item, ::LLVM::Type)}]
-      attr_reader :types
-
-      # The functions that have been defined.  This is a mapping of the
-      # {Concrete::Type} to the `LLVM::Function` that was defined.
-      #
-      # @return [{Concrete::Type => (Concrete::Item, ::LLVM::Function)}]
-      attr_reader :functions
+      # @return [{Concrete::Type => (Concrete::Item, ::LLVM::Value)}]
+      attr_reader :items
 
       # The LLVM module that is being used for compilation.
       #
       # @return [::LLVM::Module]
       attr_reader :module
 
+      # The index associated with this build.
+      #
+      # @return [Concrete::Index]
+      attr_reader :index
+
       # Initialize the build process.  This only initializes instance
       # variables.
       #
-      # @param requests [::Enumerable<Concrete::Request>] An enumerable over
+      # @param requests [::Enumerable<Concrete::Type>] An enumerable over
       #   each request that needs to be built.  The requests should be
       #   resolved, i.e. the generics for the request should resolve to a
       #   valid type.
@@ -41,18 +40,27 @@ module Carbon
         @index = index
       end
 
+      def fetch(name, default = nil)
+        result = @items.find { |(k, _v)| k.match?(name) }
+
+        return result[1] if result
+        return default if default
+        yield if block_given?
+        fail ItemNotFoundError, "Could not find item with name #{name}"
+      end
+
       # Performs the build process.  Builds each request in order by calling
       # {Concrete::Item::Base#call} on each.
       #
       # @return [::LLVM::Module] The built module.
       def call
-        @types = {}
-        @functions = {}
+        @items = {}
         @module = ::LLVM::Module.new("__carbon_main")
 
         @requests.each do |request|
-          item = @index.fetch(request.intern)
-          generics = item.generics.zip(request.generics).to_h
+          item = @index.fetch(request).first
+          generics = item.generics.map(&:name)
+            .zip(request.generics.map(&:name)).to_h
           item.call(self, generics)
         end
 

data/lib/carbon/concrete/index.rb

@@ -14,6 +14,7 @@ module Carbon
     class Index
       include TSort
       extend Forwardable
+      include Enumerable
 
       # We can't use these methods because we don't fit the bill - we don't
       # define a `tsort_each_node`, since we don't need it.  We only use
@@ -27,6 +28,8 @@ module Carbon
       undef_method :each_strongly_connected_component
       undef_method :strongly_connected_components
 
+      delegate [:each] => :items
+
       # Initialize the index with the given data.
       #
       # @api public
@@ -36,95 +39,45 @@ module Carbon
       #   completely derived from the index itself; or, rather, what's defined
       #   on the index.  See {#id}.
       def initialize(data = {})
-        @items = Concurrent::Hash.new.merge(data.fetch(:items, {}))
+        @items = ::Set.new.merge(data.fetch(:items, []))
+        @links = ::Set.new
         @id = data.fetch(:id) { id }
-        mutex
       end
 
-      # @overload fetch(name, default = CANARY)
-      #   Retrieves the item with the given symbol name.  If no item with the
-      #   given name exists, it tries the following: first, if a block is
-      #   given, the item name is yielded to the block, and the result is
-      #   returned.  Second, if the second argument is passed (i.e. isn't
-      #   `CANARY`), then that is returned instead.  Third, if neither is
-      #   true, then the method raises `KeyError`.
-      #
-      #   @api public
-      #   @example Successful fetch.
-      #     index.fetch("Carbon::Integer") # => #<Carbon::Concrete::Item::Base>
-      #   @example Failed fetch with argument.
-      #     index.fetch("Carbon::Foo", false) # => false
-      #   @example Failed fetch with block.
-      #     index.fetch("Carbon::Foo") { |n| n.sub("F", "B") }
-      #       # => "Carbon::Boo"
-      #   @example Failed fetch with both.
-      #     index.fetch("Carbon::Foo", false) { |n| n.sub("F", "B") }
-      #       # => "Carbon::Boo"
-      #   @param name [::Object] The key of the item to fetch.
-      #   @param default [::Object] The value to return if the key doesn't match
-      #     an item and a block wasn't given.
-      #   @yield [name] If the key doesn't match an item, the method yields.
-      #   @yieldparam name [::Object] The name of the item.
-      #   @return [::Object] The item, if the key matched; otherwise, the result
-      #     of the block, if given; otherwise, the value of the `default`
-      #     parameter.
-      #   @raise [KeyError] If the key doesn't match an item and neither a
-      #     block nor the second argument were passed.
-      def fetch(*options, &block)
-        mutex.synchronize { @items.fetch(*options, &block) }
-      end
+      @canary = ::Object.new
+      def fetch(type, default = @canary)
+        matching = items.map { |i| [i, i.type.match?(type)] }.select(&:last)
+        fail TooManyItemsError, "Multiple items match #{type}" if
+          matching.size > 1
+        match = matching.first
 
-      # @overload [](key)
-      #   Retrieves the item with the given symbol name.  If no item exists,
-      #   it returns `nil`.
-      #
-      #   @api public
-      #   @example Successful retrieval.
-      #     index["Carbon::Integer"] # => #<Carbon::Concrete::Item::Base>
-      #   @example Unsuccessful retrieval.
-      #     index["Carbon::Foo"] # => nil
-      #   @param key [::Object] The key of the item to lookup.
-      #   @return [::Object] The item, if it exists;
-      #   @return [nil] Otherwise.
-      def [](*options)
-        mutex.synchronize { @items[*options] }
+        return match if match
+        return yield if block_given?
+        return default if default != @canary
+        fail ItemNotFoundError, "Could not find an item named #{type}"
       end
 
-      # @overload key?(key)
-      #   Determines whether or not the key exists, and an item is paired
-      #   with it.
-      #
-      #   @api public
-      #   @example Existing key.
-      #     index.key?("Carbon::Integer") # => true
-      #   @example Non-existant key.
-      #     index.key?("Carbon::Foo") # => false
-      #   @param key [::Object] The key of the item to check.
-      #   @return [::Boolean] Whether the key exists or not.
-      def key?(*options)
-        mutex.synchronize { @items.key?(*options) }
+      def item?(type)
+        items.any? { |item| item.type.match?(type) }
       end
 
-      # Returns all of the keys in the index.  The keys and the array itself
-      # are both frozen.
-      #
-      # @api public
-      # @example
-      #   index.keys # => ["Carbon::Boolean", "Carbon::Integer"]
-      # @return [<::String>] The keys in the index.
-      def keys
-        mutex.synchronize { @items.keys.deep_freeze! }
+      def items
+        @_current ||= begin
+          current = @items.dup
+          @links.each do |link|
+            current.merge(link.items)
+          end
+
+          current.freeze
+        end
       end
 
-      # Returns all of the values (actual items) in the index.  The items, and
-      # the array containing them, are frozen.
-      #
-      # @api public
-      # @example
-      #   index.values.map(&:class) # => [Carbon::Concrete::Item::Internal, ...]
-      # @return [<Item::Base>] The values in the index.
-      def values
-        mutex.synchornize { @items.values.freeze }
+      def to_json
+        links, @links = @links, nil
+        clear! && id
+        value = Oj.dump(self, Concrete::OPTIONS)
+        @links = links
+        value
       end
 
       # The digest of the ID.  This uses the SHA256 base58 digest of the items
@@ -133,23 +86,14 @@ module Carbon
       #
       # @api public
       # @example
-      #   index.items # => {}
+      #   index.items # => []
       #   index.id # => "gjNT5GbSC-81KmUPncw-hzQAGV3GU-eAXafmkMP-Bw2GMHWM"
       # @return [::String]
       def id
-        @id ||= Carbon.hash(items.keys.join("\n"))
-      end
-
-      # The items of the index.  This is a frozen duplicate of the items.
-      # Therefore, this is not guarenteed to be up to date.
-      #
-      # @api public
-      # @example Items
-      #   index.items
-      #     # => {"Carbon::Integer" => #<Carbon::Concrete::Item::Base>}
-      # @return [{::String => Item::Base}] The items of the index.
-      def items
-        mutex.synchronize { @items.dup.deep_freeze! }
+        @_id ||= begin
+          body = (@items.map(&:type).map(&:to_s) + @links.map(&:id)).join("\n")
+          Carbon.hash(body)
+        end
       end
 
       # Adds a defined item to the index.  The item just has to respond to
@@ -161,41 +105,18 @@ module Carbon
       # @example Adding an item.
       #   index << item
       #   index.key?(item.intern) # => true
-      # @example Merging an index.
-      #   other.is_a?(Carbon::Concrete::Index) # => true
-      #   index << other
-      #   index.items.keys.to_set <= other.items.keys.to_set
-      # @note
-      #   If the item is an index instead, it passes it to {#merge} and
-      #   returns.  This usage is not recommended for {#add}, but can be
-      #   used for {#<<}.
       # @param item [Concrete::Item::Base] The item to add.
       # @return [self]
       def add(item)
-        return merge(item) if item.is_a?(Index)
-        mutex.synchronize do
-          @items[item.intern] = item
-          clear!
-        end
+        @items << item
+        clear!
       end
 
       alias_method :<<, :add
 
-      # Merges items from another index into the merged items of this index.
-      # This clears the index's cache, such that the ID ({#id}) have to be
-      # recalculated.
-      #
-      # @api public
-      # @example Merging.
-      #   index.merge(other)
-      #   index.items.keys.to_set <= other.items.keys.to_set
-      # @param index [Index] The index to merge.
-      # @return [self]
-      def merge(index)
-        mutex.synchronize do
-          @items.merge(index.items)
-          clear!
-        end
+      def link(index)
+        @links << index
+        clear!
       end
 
       # Finalizes the index.  This should only be used when all of the items
@@ -207,15 +128,10 @@ module Carbon
       #   for this instance of the index.
       # @return [self]
       def finalize
-        mutex.synchronize do
-          items = @items.map do |key, value|
-            [key, value.define(self)]
-          end.to_h
-
-          @items = items.freeze
-        end
-
-        self
+        current = @items.dup
+        items = ::Set.new(current.map { |item| item.define(self) })
+        @items = items.freeze
+        clear!
       end
 
       # Used only for {#define}.  This maps item "names" to the classes that
@@ -280,47 +196,34 @@ module Carbon
       #   request.intern # => "Main"
       #   request.generics # => []
       #   index.build(request).to_a # => [...]
-      # @param item [Item::Base] The item to build.  The {Item::Base} module
-      #   contains behavior that is required by this method (namely,
-      #   {Item::Base#corrected_dependencies}, {Item::Base#intern}, and
-      #   {Item::Base#generics}).
+      # @param item [Concrete::Type] The type to build.
       # @return [::Enumerable] The build items, if no block is given.
       # @return [void] If a block is given.
       # @yield [dep] Multiple times, each with a dependency.
       # @yieldparam dep [Request] A request.
       def build(item)
-        mutex.lock
         fail ArgumentError, "Passed item cannot be generic" if \
           item.generics.any?
         return to_enum(:build, item) unless block_given?
-        request = Request.new(item.intern, [])
 
-        build_from_request(request, &Proc.new)
-      ensure
-        mutex.unlock
+        build_from_request(item, &Proc.new)
       end
 
     private
 
-      def mutex
-        @_mutex ||= ::Mutex.new
+      def clear!
+        @_id = @_current = nil
+        self
       end
 
-      # rubocop:disable Metrics/MethodLength
       def build_from_request(request)
         components = to_enum(:each_strongly_connected_component_from, request)
         components.each do |group|
           fail TSort::Cyclic, "cyclic dependencies: #{group.join(', ')}" if \
             group.size > 1
-          begin
-            mutex.unlock
-            yield group.first
-          ensure
-            mutex.lock
-          end
+          yield group.first
         end
       end
-      # rubocop:enable Metrics/MethodLength
 
       # Iterates over all of the "children" of a node.  This iterates over all
       # of the corrected dependencies of a node, allowing the TSort module
@@ -332,16 +235,7 @@ module Carbon
       # @yieldparam request [Request]
       # @return [void]
       def tsort_each_child(node, &block)
-        @items.fetch(node.intern).corrected_dependencies(node, &block)
-      end
-
-      # Clears the cache, forcing the id to be rebuilt on next call.
-      #
-      # @api private
-      # @return [self]
-      def clear!
-        @id = nil
-        self
+        fetch(node).first.corrected_dependencies(node, &block)
       end
     end
   end