carbon-compiler 0.2.0

data/lib/carbon/compiler/node/definition.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "carbon/compiler/node/definition/directive"
+require "carbon/compiler/node/definition/enum"
+require "carbon/compiler/node/definition/function"
+require "carbon/compiler/node/definition/module"
+require "carbon/compiler/node/definition/struct"
+
+module Carbon
+  module Compiler
+    module Node
+      # A Definition.  This is in most cases a module, function, struct, enum,
+      # trait, or directive.
+      module Definition
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/definition/class.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "carbon/compiler/node/definition/struct/element"
+
+module Carbon
+  module Compiler
+    module Node
+      module Definition
+        # A class definition.  This sets up a structured block of memory
+        # for various purposes.  A Class's children are its elements.
+        class Class < Base
+          # If this definition is a data definition.  A Structure is one of
+          # many possible data definitions.
+          #
+          # @return [true]
+          def data?
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/definition/class/element.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Node
+      module Definition
+        class Class < Base
+          # An element of a class.  This contains name and type information for
+          # a class element.
+          class Element < Base
+            attributes name: 0, type: 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/definition/directive.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "carbon/compiler/node/definition/directive/function"
+
+module Carbon
+  module Compiler
+    module Node
+      module Definition
+        # A directive.  This is normally anything that starts with a colon
+        # in the source file.  This contains information about said directive.
+        class Directive < Base
+          attributes name: 0, parameters: 1
+
+          def value
+            name.value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/definition/directive/function.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Node
+      module Definition
+        class Directive < Base
+          # A directive "function."  Mainly, this is a key-value store, with
+          # the keys being the names of the parameters and the values being
+          # the types of the parameters.
+          class Function < Base
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/definition/enum.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "carbon/compiler/node/definition/enum/element"
+
+module Carbon
+  module Compiler
+    module Node
+      module Definition
+        # An Enum definition.  Enums contain a set of elements that have
+        # associated type or value information.
+        class Enum < Base
+          def data?
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/definition/enum/element.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Node
+      module Definition
+        class Enum < Base
+          # An element of an Enumerable.  This contains either type or value
+          # information.
+          class Element < Base
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/definition/function.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "carbon/compiler/node/definition/function/parameter"
+require "carbon/compiler/node/definition/function/parameters"
+require "carbon/compiler/node/definition/function/body"
+require "carbon/compiler/node/definition/function/name"
+
+module Carbon
+  module Compiler
+    module Node
+      module Definition
+        # A function definition.  This contains information about the arguments
+        # to be passed to the function, the "klass" (type) or return type of
+        # the function, the body of a function (if an extern function, this
+        # is null), and the associated {Project::Function} information, when
+        # tied.
+        class Function < Base
+          attributes _name: 0, parameters: 1, type: 2, body: 3
+
+          # If this definition is a behavior definition.  Functions are the
+          # only behavior definitions in a module.
+          #
+          # @return [true]
+          def behavior?
+            true
+          end
+
+          # The name of the function.  This is used in place of an actual
+          # node for various reasons.
+          #
+          # @return [String]
+          def name
+            @children[0].name.value
+          end
+
+          def generics
+            @children[0].generics
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/definition/function/body.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Node
+      module Definition
+        class Function < Base
+          # The body of a function.  This acts an array containing all of the
+          # statements that make up a function.
+          class Body < Base
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/definition/function/name.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Node
+      module Definition
+        class Function < Base
+          # The name of the function.  Note that this is mostly unused right
+          # now due to various reasons.
+          class Name < Base
+            attributes name: 0, generics: 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/definition/function/parameter.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Node
+      module Definition
+        class Function < Base
+          # An argument to a function.  This contains name and "klass" (type)
+          # information for a specific argument.
+          class Parameter < Base
+            attributes name: 0, type: 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/definition/function/parameters.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Node
+      module Definition
+        class Function < Base
+          # Arguments to a function.  This will eventually be turned directly
+          # into an array passed to functions.
+          class Parameters < Base
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/definition/module.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Node
+      module Definition
+        # A module definition.  This has one child, a {ModuleName} node.
+        class Module < Base
+          attributes name: 0
+
+          # If this definition is an identity definition.  Module definitions
+          # are the only identity definitions in a module.
+          #
+          # @return [true]
+          def identity?
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/definition/struct.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "carbon/compiler/node/definition/struct/element"
+
+module Carbon
+  module Compiler
+    module Node
+      module Definition
+        # A struct definition.  This sets up a structured block of memory
+        # for various purposes.  A Struct's children are its elements.
+        class Struct < Base
+          # If this definition is a data definition.  A Structure is one of
+          # many possible data definitions.
+          #
+          # @return [true]
+          def data?
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/definition/struct/element.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Node
+      module Definition
+        class Struct < Base
+          # An element of a struct.  This contains name and "klass" (type)
+          # information for a structure element.
+          class Element < Base
+            attributes name: 0, type: 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/etype.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "carbon/compiler/node/etype/option"
+require "carbon/compiler/node/etype/star"
+
+module Carbon
+  module Compiler
+    module Node
+      class EType < Base
+        def expand(file, typify = true)
+          catch(:invalid) { check_valid_parts(file) } or return {}
+          return blank_mapping if clean?
+
+          # now we know that children[0..-2] are all parts and children[-1] is
+          # an option... we just have to expand the option now.
+          children[-1].expand(file).map do |key, value|
+            value = children[0..-2].concat(value)
+
+            if typify
+              { Concrete::Type.new(Concrete::Type::Name.new([key], nil)) =>
+                Concrete::Type.new(Concrete::Type::Name.new(value, nil)) }
+            else
+              { key => value }
+            end
+          end.inject(:merge)
+        end
+
+        def clean?
+          children.none? { |c| c.is_a?(Base) }
+        end
+
+        def to_type
+          return unless clean?
+          Concrete::Type.new(Concrete::Type::Name.new(children, nil),
+            location: location)
+        end
+
+      private
+
+        def blank_mapping
+          type = Concrete::Type.new(Concrete::Type::Name.new([children.last],
+            nil))
+          { type => to_type }
+        end
+
+        def check_valid_parts(file)
+          error_misplaced_option(file) && throw(:invalid) if children[0..-2]\
+            .any? { |c| c.is_a?(Base) }
+          error_included_star(file) && throw(:invalid) if children[-1]\
+            .is_a?(EType::Star)
+          true
+        end
+
+        def error_misplaced_option(file)
+          file.emit("Module/Name/InvalidExtended", node.location)
+        end
+
+        def error_included_star(file)
+          file.emit("System/Error", node.location,
+            "Cannot handle star extended types")
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/etype/option.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Node
+      class EType < Base
+        class Option < Base
+          def expand(file)
+            children.map do |child|
+              # child.is_a?(Node::EType) # => true
+              if child.clean?
+                type = child.to_type
+                last = type.name.parts.last
+                { last => type.name.parts }
+              else
+                child.expand(file, false)
+              end
+            end.inject(:merge)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/etype/star.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Node
+      class EType < Base
+        class Star < Base
+        end
+      end
+    end
+  end
+end