carbon-compiler 0.2.0

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

@@ -0,0 +1,18 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "carbon/compiler/node/expression/assignment"
+require "carbon/compiler/node/expression/call"
+require "carbon/compiler/node/expression/literal"
+require "carbon/compiler/node/expression/operation"
+require "carbon/compiler/node/expression/unit"
+
+module Carbon
+  module Compiler
+    module Node
+      # An expression.
+      module Expression
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/expression/assignment.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Node
+      module Expression
+        # An assignment expression.  This typically takes the form of
+        # `<Expression> = <Expression>`.  There are three cases for assignments:
+        # a) an attribute assignment; b) an access assignment; and c) an
+        # identifier assignment.  The first and second are turned into
+        # function calls using {Call::Dispatch}; the last is kept as-is,
+        # and turns into a store.
+        # This has three children: the left hand side, the operation, and
+        # the right hand side.
+        class Assignment < Base
+          attributes left: 0, op: 1, right: 2
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/expression/call.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "carbon/compiler/node/expression/call/parameters"
+require "carbon/compiler/node/expression/call/access"
+require "carbon/compiler/node/expression/call/attribute"
+require "carbon/compiler/node/expression/call/enum"
+require "carbon/compiler/node/expression/call/module"
+require "carbon/compiler/node/expression/call/self"
+require "carbon/compiler/node/expression/call/unified"
+
+module Carbon
+  module Compiler
+    module Node
+      module Expression
+        # Contains all of the ways a call can be made/handled.
+        module Call
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/expression/call/access.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Node
+      module Expression
+        module Call
+          # An "Access" call.  An access call takes the form of
+          # `<Expression>[<Arguments>]`.  This is used to index arrays.
+          # An access call has two children: an expression and the arguments
+          # for the access.  In the example below, there is only one argument.
+          #
+          # @example
+          #   # let a: Carbon::Pointer<Carbon::Integer>;
+          #   a[0]; # => Carbon::Integer
+          class Access < Base
+            attributes expression: 0, parameters: 1, generics: 2
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/expression/call/attribute.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Node
+      module Expression
+        module Call
+          # An attribute call.  This is used for accessing an "attribute" of
+          # a module.  This takes the form of `<Expression>.<Name>`.  This
+          # has two children: an expression, and a name.
+          #
+          # @example
+          #   # let a: Carbon::Pointer<Carbon::Integer>;
+          #   a.value = 1;
+          class Attribute < Base
+            attributes expression: 0, name: 1, generics: 2
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/expression/call/enum.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Node
+      module Expression
+        module Call
+          # An Enum call.  This is a call used to create an "enum" value.
+          # This takes the form of
+          # `<ModuleName>.<ModuleNamePart>.(<Arguments>)`.  This has three
+          # children: the module name, the enum element name, and the
+          # arguments.
+          #
+          # @example
+          #   # let a: Some::Enum;
+          #   a = Some::Enum.Red();
+          class Enum < Base
+            attributes module: 0, name: 1, parameters: 2, generics: 3
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/expression/call/module.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Node
+      module Expression
+        module Call
+          # A basic module call.  This is the most basic version of a call.
+          # This takes the form `<ModuleName>.<Name>(<Arguments>)`.
+          # This has three children: the module name, the name of the
+          # function, and the arguments.
+          #
+          # @example
+          #   let a: Carbon::Pointer<Carbon::Integer>;
+          #   Carbon::Pointer<Carbon::Integer>.value=(a, 1);
+          class Module < Base
+            attributes module: 0, name: 1, parameters: 2, generics: 3
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/expression/call/parameters.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Node
+      module Expression
+        module Call
+          # The arguments to the call.  This may be turned into a pure array
+          # in later versions.
+          class Parameters < Base
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/expression/call/self.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Node
+      module Expression
+        module Call
+          # Unused.
+          class Self < Base
+            attributes name: 0, parameters: 1, generics: 2
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/expression/call/unified.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Node
+      module Expression
+        module Call
+          # A "unified" call.  This is the extended version of the module
+          # call.  This can be turned into a module call by taking the
+          # module type of the expression and using that as the base, and
+          # passing the expression as the first parameter.  This takes the
+          # form `<Expression>.<Name>(<Arguments>)`.  This has three
+          # children: an expression, a name, and the arguments.
+          #
+          # @example
+          #   # let a: Carbon::Pointer<Carbon::Integer>;
+          #   a.size(); # Same as the following:
+          #   Carbon::Pointer<Carbon::Integer>.size(a);
+          class Unified < Base
+            attributes expression: 0, name: 1, parameters: 2, generics: 3
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/expression/literal.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Node
+      module Expression
+        # A literal expression.  Contains information about how the literal
+        # expression should be represented.
+        class Literal < Base
+          # Replacements for strings.
+          #
+          # @return [{String => String}]
+          REPLACE = {
+            '\"' => '"',
+            '\\\\' => '\\',
+            '\/' => "/",
+            '\b' => "\b",
+            '\f' => "\f",
+            '\n' => "\n",
+            '\r' => "\r",
+            '\t' => "\t"
+          }.freeze
+
+          # Yields a LLVM value representing the literal.
+          #
+          # @return [::Numeric, ::String]
+          def value
+            case @children.first.type
+            when :NUMBER then number_value
+              # LLVM.Int(@children.first.value.to_i)
+            when :FLOAT
+              LLVM.Float(@children.first.value.to_f)
+            when :STRING
+              fail
+              @children.first.value[1..-2]
+                .gsub(%r{\\["\\/bfnrt]}, REPLACE)
+            else fail
+            end
+          end
+
+          # Yields the Carbon type representing the literal.
+          #
+          # @return [Carbon::Concrete::Type]
+          def type
+            case @children.first.type
+            # when :NUMBER then Carbon::Type("Carbon::Int32")
+            when :NUMBER then number_type
+            when :FLOAT then Carbon::Type("Carbon::Float")
+            when :STRING then Carbon::Type("Carbon::String")
+            else fail
+            end
+          end
+
+        private
+
+          def raw
+            @children.first.value
+          end
+
+          def postfix
+            raw.match(/(?:0x[a-f0-9]+|(?:0|[1-9][0-9]*))(?:_?([ui][0-9]+))?/)[1] || "i32"
+          end
+
+          def number
+            raw.match(/(0x[a-f0-9]+|(?:0|[1-9][0-9]*))(?:_?(?:[ui][0-9]+))?/)[1]
+          end
+
+          def number_value
+            LLVM.const_get("Int#{postfix[1..-1]}").from_i(number.to_i,
+              postfix[0] == "i")
+          end
+
+          def number_type
+            sign = postfix[0] == "i" ? :signed : :unsigned
+            size = postfix[1..-1].to_i
+            Core::Int.find(sign: sign, size: size).name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/expression/operation.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "carbon/compiler/node/expression/operation/and"
+require "carbon/compiler/node/expression/operation/neq"
+require "carbon/compiler/node/expression/operation/normal"
+require "carbon/compiler/node/expression/operation/or"
+
+module Carbon
+  module Compiler
+    module Node
+      module Expression
+        # An operation.  This is just the superclass for the potential
+        # operations.
+        class Operation < Base
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/expression/operation/and.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Node
+      module Expression
+        class Operation < Base
+          # An "And" operation.  This is generated internally and cannot be
+          # redefined by defining an "And" function.
+          # This has three children: the left hand side, the operation, and
+          # the right hand side.  This has the form `<Left> && <Right>`.
+          class And < Operation
+            attributes left: 0, op: 1, right: 2
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/expression/operation/neq.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Node
+      module Expression
+        class Operation < Base
+          # A "Neq" operation.  This is generated internally and cannot be
+          # redefined by defining a "Neq" function.
+          # This has three children: the left hand side, the operation, and
+          # the right hand side.  This has the form `<Left> != <Right>`.
+          # This is redefined in terms of the Eq operation (`==`).
+          class Neq < Operation
+            attributes left: 0, op: 1, right: 2, func: 3
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/expression/operation/normal.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Node
+      module Expression
+        class Operation < Base
+          # A normal operation.  This is redefined into a {Call::Dispatch}
+          # in order to turn all operations into function calls.
+          # This has three children: the left hand side, the operation,
+          # and the right hand side.  This takes the form `<Left> <Op> <Right>`.
+          class Normal < Operation
+            attributes left: 0, op: 1, right: 2
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/expression/operation/or.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Node
+      module Expression
+        class Operation < Base
+          # An "Or" operation.  This is generated internally and cannot be
+          # redefined by defining an "Or" function.
+          # This has three children: the left hand side, the operation, and
+          # the right hand side.  This has the form `<Left> || <Right>`.
+          class Or < Operation
+            attributes left: 0, op: 1, right: 2
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/node/expression/unit.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Node
+      module Expression
+        # A "unit".  This takes the form of `(<Expressions>)`.  This is
+        # used as a sort of "mini-struct".  Mostly unused at the moment.
+        class Unit < Base
+          attr_reader :type
+        end
+      end
+    end
+  end
+end