expressir 0.2.2 → 0.2.3

data/lib/expressir/express_exp/visitor.rb

@@ -1,7 +1,8 @@
 require 'expressir/express_exp/generated/ExpressBaseVisitor'
 require 'expressir/model'
 
-# issues:
+# static shorthands are unwrapped
+# - entity attributes, function/procedure parameters, local variables
 #
 # reference type is not recognized
 # see note in A.1.5 Interpreted identifiers
@@ -11,8 +12,8 @@ require 'expressir/model'
 # > declarations, so that subsequent passes are then able to distinguish a veriable_ref from a function_ref,
 # > for example.
 #
-# - xxxRef - merged to Ref
-# - entityConstructor, functionCall, procedureCall
+# - xxxRef - merged to SimpleReference
+# - entityConstructor, functionCall - merged to Call
 # 
 # difference between generalized and instantiable types is not recognized
 # see note in 8.6.2 Parameter data types
@@ -32,11 +33,22 @@ module Expressir
 
       def visit(ctx)
         result = super(ctx)
+        attach_parent(ctx, result)
         attach_remarks(ctx, result)
         result
       end
 
-      def attach_remarks(ctx, item)
+      def attach_parent(ctx, node)
+        if node.class.method_defined? :children
+          node.children.each do |child_node|
+            if child_node.class.method_defined? :parent
+              child_node.parent = node
+            end
+          end
+        end
+      end
+
+      def attach_remarks(ctx, node)
         # get remark tokens
         start_index, stop_index = if ctx.instance_of? Generated::ExpressParser::SyntaxContext
           [0, @tokens.size - 1]
@@ -66,16 +78,16 @@ module Expressir
             end
 
             # attach tagged remark
-            remark_tag = match[1]
+            remark_tag = match[1].downcase
             remark_content = match[2].strip
 
-            current_item = item
+            current_node = node
             remark_tag.split('.').each do |id|
-              if current_item
-                if current_item.class.method_defined? :scope_items
-                  current_item = current_item.scope_items.find{|x| x.id == id}
+              if current_node
+                if current_node.class.method_defined? :children
+                  current_node = current_node.children.find{|x| x.id.downcase == id}
                 else
-                  current_item = nil
+                  current_node = nil
                   break
                 end
               else
@@ -83,9 +95,9 @@ module Expressir
               end
             end
 
-            if current_item
-              current_item.remarks ||= []
-              current_item.remarks << remark_content
+            if current_node
+              current_node.remarks ||= []
+              current_node.remarks << remark_content
 
               # mark remark as attached, so that it is not attached again at higher nesting level
               @attached_remarks << remark_token
@@ -97,7 +109,7 @@ module Expressir
       def visitAttributeRef(ctx)
         id = visit(ctx.attributeId())
 
-        Model::Ref.new({
+        Model::Expressions::SimpleReference.new({
           id: id
         })
       end
@@ -105,7 +117,7 @@ module Expressir
       def visitConstantRef(ctx)
         id = visit(ctx.constantId())
 
-        Model::Ref.new({
+        Model::Expressions::SimpleReference.new({
           id: id
         })
       end
@@ -113,7 +125,7 @@ module Expressir
       def visitEntityRef(ctx)
         id = visit(ctx.entityId())
 
-        Model::Ref.new({
+        Model::Expressions::SimpleReference.new({
           id: id
         })
       end
@@ -121,7 +133,7 @@ module Expressir
       def visitEnumerationRef(ctx)
         id = visit(ctx.enumerationId())
 
-        Model::Ref.new({
+        Model::Expressions::SimpleReference.new({
           id: id
         })
       end
@@ -129,7 +141,7 @@ module Expressir
       def visitFunctionRef(ctx)
         id = visit(ctx.functionId())
 
-        Model::Ref.new({
+        Model::Expressions::SimpleReference.new({
           id: id
         })
       end
@@ -137,7 +149,7 @@ module Expressir
       def visitParameterRef(ctx)
         id = visit(ctx.parameterId())
 
-        Model::Ref.new({
+        Model::Expressions::SimpleReference.new({
           id: id
         })
       end
@@ -145,7 +157,7 @@ module Expressir
       def visitProcedureRef(ctx)
         id = visit(ctx.procedureId())
 
-        Model::Ref.new({
+        Model::Expressions::SimpleReference.new({
           id: id
         })
       end
@@ -153,7 +165,7 @@ module Expressir
       def visitRuleLabelRef(ctx)
         id = visit(ctx.ruleLabelId())
 
-        Model::Ref.new({
+        Model::Expressions::SimpleReference.new({
           id: id
         })
       end
@@ -161,7 +173,7 @@ module Expressir
       def visitRuleRef(ctx)
         id = visit(ctx.ruleId())
 
-        Model::Ref.new({
+        Model::Expressions::SimpleReference.new({
           id: id
         })
       end
@@ -169,7 +181,7 @@ module Expressir
       def visitSchemaRef(ctx)
         id = visit(ctx.schemaId())
 
-        Model::Ref.new({
+        Model::Expressions::SimpleReference.new({
           id: id
         })
       end
@@ -177,7 +189,7 @@ module Expressir
       def visitSubtypeConstraintRef(ctx)
         id = visit(ctx.subtypeConstraintId())
 
-        Model::Ref.new({
+        Model::Expressions::SimpleReference.new({
           id: id
         })
       end
@@ -185,7 +197,7 @@ module Expressir
       def visitTypeLabelRef(ctx)
         id = visit(ctx.typeLabelId())
 
-        Model::Ref.new({
+        Model::Expressions::SimpleReference.new({
           id: id
         })
       end
@@ -193,7 +205,7 @@ module Expressir
       def visitTypeRef(ctx)
         id = visit(ctx.typeId())
 
-        Model::Ref.new({
+        Model::Expressions::SimpleReference.new({
           id: id
         })
       end
@@ -201,7 +213,7 @@ module Expressir
       def visitVariableRef(ctx)
         id = visit(ctx.variableId())
 
-        Model::Ref.new({
+        Model::Expressions::SimpleReference.new({
           id: id
         })
       end
@@ -224,13 +236,13 @@ module Expressir
 
       def visitAddLikeOp(ctx)
         if ctx.text == '+'
-          Model::Operators::Addition.new()
+          Model::Expressions::BinaryExpression::ADDITION
         elsif ctx.text == '-'
-          Model::Operators::Subtraction.new()
+          Model::Expressions::BinaryExpression::SUBTRACTION
         elsif ctx.OR()
-          Model::Operators::Or.new()
+          Model::Expressions::BinaryExpression::OR
         elsif ctx.XOR()
-          Model::Operators::Xor.new()
+          Model::Expressions::BinaryExpression::XOR
         else
           raise 'Invalid state'
         end
@@ -280,17 +292,7 @@ module Expressir
 
       def visitAliasStmt(ctx)
         id = visit(ctx.variableId())
-        expression = if ctx.qualifier().length > 0
-          ref = visit(ctx.generalRef())
-          qualifiers = ctx.qualifier().map{|ctx| visit(ctx)}
-
-          Model::Expressions::QualifiedRef.new({
-            ref: ref,
-            qualifiers: qualifiers
-          })
-        else
-          visit(ctx.generalRef())
-        end
+        expression = handleQualifiedRef(visit(ctx.generalRef()), ctx.qualifier())
         statements = ctx.stmt().map{|ctx| visit(ctx)}
 
         Model::Statements::Alias.new({
@@ -317,20 +319,9 @@ module Expressir
       end
 
       def visitAssignmentStmt(ctx)
+        ref = handleQualifiedRef(visit(ctx.generalRef()), ctx.qualifier())
         expression = visit(ctx.expression())
 
-        ref = if ctx.qualifier().length > 0
-          ref = visit(ctx.generalRef())
-          qualifiers = ctx.qualifier().map{|ctx| visit(ctx)}
-
-          Model::Expressions::QualifiedRef.new({
-            ref: ref,
-            qualifiers: qualifiers
-          })
-        else
-          visit(ctx.generalRef())
-        end
-
         Model::Statements::Assignment.new({
           ref: ref,
           expression: expression
@@ -345,20 +336,16 @@ module Expressir
         handleSimpleId(ctx.SimpleId())
       end
 
-      def visitAttributeQualifier(ctx)
-        attribute = visit(ctx.attributeRef())
-
-        Model::Expressions::AttributeQualifier.new({
-          attribute: attribute
-        })
+      def visitAttributeReference(ctx)
+        raise 'Invalid state'
       end
 
       def visitBagType(ctx)
-        bound1, bound2 = if ctx.boundSpec()
-          [
-            visit(ctx.boundSpec().bound1().numericExpression().simpleExpression()),
-            visit(ctx.boundSpec().bound2().numericExpression().simpleExpression())
-          ]
+        bound1 = if ctx.boundSpec()
+          visit(ctx.boundSpec().bound1().numericExpression().simpleExpression())
+        end
+        bound2 = if ctx.boundSpec()
+          visit(ctx.boundSpec().bound2().numericExpression().simpleExpression())
         end
         base_type = visit(ctx.instantiableType())
         
@@ -402,7 +389,7 @@ module Expressir
       def visitBuiltInConstant(ctx)
         id = ctx.text
 
-        Model::Ref.new({
+        Model::Expressions::SimpleReference.new({
           id: id
         })
       end
@@ -410,7 +397,7 @@ module Expressir
       def visitBuiltInFunction(ctx)
         id = ctx.text
 
-        Model::Ref.new({
+        Model::Expressions::SimpleReference.new({
           id: id
         })
       end
@@ -418,21 +405,19 @@ module Expressir
       def visitBuiltInProcedure(ctx)
         id = ctx.text
 
-        Model::Ref.new({
+        Model::Expressions::SimpleReference.new({
           id: id
         })
       end
 
       def visitCaseAction(ctx)
-        expressions = ctx.caseLabel().map{|ctx| visit(ctx.expression())}
+        labels = ctx.caseLabel().map{|ctx| visit(ctx.expression())}
         statement = visit(ctx.stmt())
 
-        expressions.map do |expression|
-          Model::Statements::CaseAction.new({
-            expression: expression,
-            statement: statement
-          })
-        end
+        Model::Statements::CaseAction.new({
+          labels: labels,
+          statement: statement
+        })
       end
 
       def visitCaseLabel(ctx)
@@ -440,14 +425,14 @@ module Expressir
       end
 
       def visitCaseStmt(ctx)
-        selector = visit(ctx.selector().expression())
+        expression = visit(ctx.selector().expression())
         actions = ctx.caseAction().map{|ctx| visit(ctx)}.flatten
         otherwise_statement = if ctx.stmt()
           visit(ctx.stmt())
         end
 
         Model::Statements::Case.new({
-          selector: selector,
+          expression: expression,
           actions: actions,
           otherwise_statement: otherwise_statement
         })
@@ -530,20 +515,21 @@ module Expressir
       end
 
       def visitDerivedAttr(ctx)
+        supertype_attribute = if ctx.attributeDecl().redeclaredAttribute() && ctx.attributeDecl().redeclaredAttribute().qualifiedAttribute()
+          visit(ctx.attributeDecl().redeclaredAttribute().qualifiedAttribute())
+        end
         id = if ctx.attributeDecl().attributeId()
           visit(ctx.attributeDecl().attributeId())
         elsif ctx.attributeDecl().redeclaredAttribute() && ctx.attributeDecl().redeclaredAttribute().attributeId()
           visit(ctx.attributeDecl().redeclaredAttribute().attributeId())
         end
-        supertype_attribute = if ctx.attributeDecl().redeclaredAttribute() && ctx.attributeDecl().redeclaredAttribute().qualifiedAttribute()
-          visit(ctx.attributeDecl().redeclaredAttribute().qualifiedAttribute())
-        end
         type = visit(ctx.parameterType())
         expression = visit(ctx.expression())
 
-        Model::Derived.new({
-          id: id,
+        Model::Attribute.new({
+          kind: Model::Attribute::DERIVED,
           supertype_attribute: supertype_attribute,
+          id: id,
           type: type,
           expression: expression
         })
@@ -570,7 +556,7 @@ module Expressir
           expression = visit(ctx.expression())
           repetition = visit(ctx.repetition().numericExpression().simpleExpression())
 
-          Model::Expressions::AggregateElement.new({
+          Model::Expressions::AggregateItem.new({
             expression: expression,
             repetition: repetition
           })
@@ -584,11 +570,11 @@ module Expressir
       end
 
       def visitEntityConstructor(ctx)
-        entity = visit(ctx.entityRef())
+        ref = visit(ctx.entityRef())
         parameters = ctx.expression().map{|ctx| visit(ctx)}
 
-        Model::Expressions::EntityConstructor.new({
-          entity: entity,
+        Model::Expressions::Call.new({
+          ref: ref,
           parameters: parameters
         })
       end
@@ -596,26 +582,25 @@ module Expressir
       def visitEntityDecl(ctx)
         id = visit(ctx.entityHead().entityId())
         abstract = if ctx.entityHead().subsuper().supertypeConstraint()
-          !!ctx.entityHead().subsuper().supertypeConstraint().abstractEntityDeclaration()
-        end
-        abstract_supertype = if ctx.entityHead().subsuper().supertypeConstraint()
-          !!ctx.entityHead().subsuper().supertypeConstraint().abstractSupertypeDeclaration()
+          !!ctx.entityHead().subsuper().supertypeConstraint().abstractEntityDeclaration() || !!ctx.entityHead().subsuper().supertypeConstraint().abstractSupertypeDeclaration()
         end
-        supertypes = if ctx.entityHead().subsuper().subtypeDeclaration()
-          ctx.entityHead().subsuper().subtypeDeclaration().entityRef().map{|ctx| visit(ctx)}
-        end
-        subtype_expression = if ctx.entityHead().subsuper().supertypeConstraint() && ctx.entityHead().subsuper().supertypeConstraint().abstractSupertypeDeclaration() && ctx.entityHead().subsuper().supertypeConstraint().abstractSupertypeDeclaration().subtypeConstraint()
+        supertype_expression = if ctx.entityHead().subsuper().supertypeConstraint() && ctx.entityHead().subsuper().supertypeConstraint().abstractSupertypeDeclaration() && ctx.entityHead().subsuper().supertypeConstraint().abstractSupertypeDeclaration().subtypeConstraint()
           visit(ctx.entityHead().subsuper().supertypeConstraint().abstractSupertypeDeclaration().subtypeConstraint().supertypeExpression())
         elsif ctx.entityHead().subsuper().supertypeConstraint() && ctx.entityHead().subsuper().supertypeConstraint().supertypeRule()
           visit(ctx.entityHead().subsuper().supertypeConstraint().supertypeRule().subtypeConstraint().supertypeExpression())
         end
-        explicit = ctx.entityBody().explicitAttr().map{|ctx| visit(ctx)}.flatten
-        derived = if ctx.entityBody().deriveClause()
-          ctx.entityBody().deriveClause().derivedAttr().map{|ctx| visit(ctx)}
-        end
-        inverse = if ctx.entityBody().inverseClause()
-          ctx.entityBody().inverseClause().inverseAttr().map{|ctx| visit(ctx)}
+        subtype_of = if ctx.entityHead().subsuper().subtypeDeclaration()
+          ctx.entityHead().subsuper().subtypeDeclaration().entityRef().map{|ctx| visit(ctx)}
         end
+        attributes = [
+          *ctx.entityBody().explicitAttr().map{|ctx| visit(ctx)}.flatten,
+          *if ctx.entityBody().deriveClause()
+            ctx.entityBody().deriveClause().derivedAttr().map{|ctx| visit(ctx)}
+          end,
+          *if ctx.entityBody().inverseClause()
+            ctx.entityBody().inverseClause().inverseAttr().map{|ctx| visit(ctx)}
+          end
+        ]
         unique = if ctx.entityBody().uniqueClause()
           ctx.entityBody().uniqueClause().uniqueRule().map{|ctx| visit(ctx)}
         end
@@ -626,12 +611,9 @@ module Expressir
         Model::Entity.new({
           id: id,
           abstract: abstract,
-          abstract_supertype: abstract_supertype,
-          supertypes: supertypes,
-          subtype_expression: subtype_expression,
-          explicit: explicit,
-          derived: derived,
-          inverse: inverse,
+          supertype_expression: supertype_expression,
+          subtype_of: subtype_of,
+          attributes: attributes,
           unique: unique,
           where: where
         })
@@ -661,14 +643,10 @@ module Expressir
         if ctx.typeRef()
           ref = visit(ctx.typeRef())
           attribute = visit(ctx.enumerationRef())
-          attribute_qualifier = Model::Expressions::AttributeQualifier.new({
-            attribute: attribute
-          })
-          qualifiers = [attribute_qualifier]
   
-          Model::Expressions::QualifiedRef.new({
+          Model::Expressions::AttributeReference.new({
             ref: ref,
-            qualifiers: qualifiers
+            attribute: attribute
           })
         else
           visit(ctx.enumerationRef())
@@ -705,17 +683,19 @@ module Expressir
         type = visit(ctx.parameterType())
 
         decls.map do |decl|
+          supertype_attribute = if decl.redeclaredAttribute() && decl.redeclaredAttribute().qualifiedAttribute()
+            visit(decl.redeclaredAttribute().qualifiedAttribute())
+          end
           id = if decl.attributeId()
             visit(decl.attributeId())
           elsif decl.redeclaredAttribute() && decl.redeclaredAttribute().attributeId()
             visit(decl.redeclaredAttribute().attributeId())
           end
-          supertype_attribute = if decl.redeclaredAttribute() && decl.redeclaredAttribute().qualifiedAttribute()
-            visit(decl.redeclaredAttribute().qualifiedAttribute())
-          end
-          Model::Explicit.new({
-            id: id,
+
+          Model::Attribute.new({
+            kind: Model::Attribute::EXPLICIT,
             supertype_attribute: supertype_attribute,
+            id: id,
             optional: optional,
             type: type
           })
@@ -725,11 +705,13 @@ module Expressir
       def visitExpression(ctx)
         if ctx.relOpExtended()
           operator = visit(ctx.relOpExtended())
-          operands = ctx.simpleExpression().map{|ctx| visit(ctx)}
+          operand1 = visit(ctx.simpleExpression()[0])
+          operand2 = visit(ctx.simpleExpression()[1])
 
-          Model::Expressions::Expression.new({
+          Model::Expressions::BinaryExpression.new({
             operator: operator,
-            operands: operands
+            operand1: operand1,
+            operand2: operand2
           })
         else
           visit(ctx.simpleExpression()[0])
@@ -738,12 +720,14 @@ module Expressir
 
       def visitFactor(ctx)
         if ctx.child_at(1) && ctx.child_at(1).text == '**'
-          operator = Model::Operators::Exponentiation.new()
-          operands = ctx.simpleFactor().map{|ctx| visit(ctx)}
+          operator = Model::Expressions::BinaryExpression::EXPONENTIATION
+          operand1 = visit(ctx.simpleFactor()[0])
+          operand2 = visit(ctx.simpleFactor()[1])
 
-          Model::Expressions::Expression.new({
+          Model::Expressions::BinaryExpression.new({
             operator: operator,
-            operands: operands
+            operand1: operand1,
+            operand2: operand2
           })
         else
           visit(ctx.simpleFactor()[0])
@@ -763,7 +747,7 @@ module Expressir
       end
 
       def visitFunctionCall(ctx)
-        function = if ctx.builtInFunction()
+        ref = if ctx.builtInFunction()
           visit(ctx.builtInFunction())
         elsif ctx.functionRef()
           visit(ctx.functionRef())
@@ -774,8 +758,8 @@ module Expressir
           ctx.actualParameterList().parameter().map{|ctx| visit(ctx.expression)}
         end
 
-        Model::Expressions::FunctionCall.new({
-          function: function,
+        Model::Expressions::Call.new({
+          ref: ref,
           parameters: parameters
         })
       end
@@ -788,7 +772,7 @@ module Expressir
         constants = if ctx.algorithmHead().constantDecl()
           ctx.algorithmHead().constantDecl().constantBody().map{|ctx| visit(ctx)}
         end
-        locals = if ctx.algorithmHead().localDecl()
+        variables = if ctx.algorithmHead().localDecl()
           ctx.algorithmHead().localDecl().localVariable().map{|ctx| visit(ctx)}.flatten
         end
         declarations = ctx.algorithmHead().declaration().map{|ctx| visit(ctx)}
@@ -800,7 +784,7 @@ module Expressir
           return_type: return_type,
           declarations: declarations,
           constants: constants,
-          locals: locals,
+          variables: variables,
           statements: statements
         })
       end
@@ -842,11 +826,11 @@ module Expressir
       end
 
       def visitGeneralArrayType(ctx)
-        bound1, bound2 = if ctx.boundSpec()
-          [
-            visit(ctx.boundSpec().bound1().numericExpression().simpleExpression()),
-            visit(ctx.boundSpec().bound2().numericExpression().simpleExpression())
-          ]
+        bound1 = if ctx.boundSpec()
+          visit(ctx.boundSpec().bound1().numericExpression().simpleExpression())
+        end
+        bound2 = if ctx.boundSpec()
+          visit(ctx.boundSpec().bound2().numericExpression().simpleExpression())
         end
         optional = !!ctx.OPTIONAL()
         unique = !!ctx.UNIQUE()
@@ -862,11 +846,11 @@ module Expressir
       end
 
       def visitGeneralBagType(ctx)
-        bound1, bound2 = if ctx.boundSpec()
-          [
-            visit(ctx.boundSpec().bound1().numericExpression().simpleExpression()),
-            visit(ctx.boundSpec().bound2().numericExpression().simpleExpression())
-          ]
+        bound1 = if ctx.boundSpec()
+          visit(ctx.boundSpec().bound1().numericExpression().simpleExpression())
+        end
+        bound2 = if ctx.boundSpec()
+          visit(ctx.boundSpec().bound2().numericExpression().simpleExpression())
         end
         base_type = visit(ctx.parameterType())
         
@@ -878,11 +862,11 @@ module Expressir
       end
 
       def visitGeneralListType(ctx)
-        bound1, bound2 = if ctx.boundSpec()
-          [
-            visit(ctx.boundSpec().bound1().numericExpression().simpleExpression()),
-            visit(ctx.boundSpec().bound2().numericExpression().simpleExpression())
-          ]
+        bound1 = if ctx.boundSpec()
+          visit(ctx.boundSpec().bound1().numericExpression().simpleExpression())
+        end
+        bound2 = if ctx.boundSpec()
+          visit(ctx.boundSpec().bound2().numericExpression().simpleExpression())
         end
         unique = !!ctx.UNIQUE()
         base_type = visit(ctx.parameterType())
@@ -906,11 +890,11 @@ module Expressir
       end
 
       def visitGeneralSetType(ctx)
-        bound1, bound2 = if ctx.boundSpec()
-          [
-            visit(ctx.boundSpec().bound1().numericExpression().simpleExpression()),
-            visit(ctx.boundSpec().bound2().numericExpression().simpleExpression())
-          ]
+        bound1 = if ctx.boundSpec()
+          visit(ctx.boundSpec().bound1().numericExpression().simpleExpression())
+        end
+        bound2 = if ctx.boundSpec()
+          visit(ctx.boundSpec().bound2().numericExpression().simpleExpression())
         end
         base_type = visit(ctx.parameterType())
         
@@ -941,12 +925,8 @@ module Expressir
         })
       end
 
-      def visitGroupQualifier(ctx)
-        entity = visit(ctx.entityRef())
-
-        Model::Expressions::GroupQualifier.new({
-          entity: entity
-        })
+      def visitGroupReference(ctx)
+        raise 'Invalid state'
       end
 
       def visitIfStmt(ctx)
@@ -993,16 +973,8 @@ module Expressir
         raise 'Invalid state'
       end
 
-      def visitIndexQualifier(ctx)
-        index1 = visit(ctx.index1().index().numericExpression().simpleExpression())
-        index2 = if ctx.index2()
-          visit(ctx.index2().index().numericExpression().simpleExpression())
-        end
-
-        Model::Expressions::IndexQualifier.new({
-          index1: index1,
-          index2: index2
-        })
+      def visitIndexReference(ctx)
+        raise 'Invalid state'
       end
 
       def visitInstantiableType(ctx)
@@ -1059,29 +1031,29 @@ module Expressir
 
       def visitIntervalOp(ctx)
         if ctx.text == '<'
-          Model::Operators::LessThan.new()
+          Model::Expressions::BinaryExpression::LESS_THAN
         elsif ctx.text == '<='
-          Model::Operators::LessThanOrEqual.new()
+          Model::Expressions::BinaryExpression::LESS_THAN_OR_EQUAL
         else
           raise 'Invalid state'
         end
       end
 
       def visitInverseAttr(ctx)
+        supertype_attribute = if ctx.attributeDecl().redeclaredAttribute() && ctx.attributeDecl().redeclaredAttribute().qualifiedAttribute()
+          visit(ctx.attributeDecl().redeclaredAttribute().qualifiedAttribute())
+        end
         id = if ctx.attributeDecl().attributeId()
           visit(ctx.attributeDecl().attributeId())
         elsif ctx.attributeDecl().redeclaredAttribute() && ctx.attributeDecl().redeclaredAttribute().attributeId()
           visit(ctx.attributeDecl().redeclaredAttribute().attributeId())
         end
-        supertype_attribute = if ctx.attributeDecl().redeclaredAttribute() && ctx.attributeDecl().redeclaredAttribute().qualifiedAttribute()
-          visit(ctx.attributeDecl().redeclaredAttribute().qualifiedAttribute())
-        end
         type = if ctx.SET()
-          bound1, bound2 = if ctx.boundSpec()
-            [
-              visit(ctx.boundSpec().bound1().numericExpression().simpleExpression()),
-              visit(ctx.boundSpec().bound2().numericExpression().simpleExpression())
-            ]
+          bound1 = if ctx.boundSpec()
+            visit(ctx.boundSpec().bound1().numericExpression().simpleExpression())
+          end
+          bound2 = if ctx.boundSpec()
+            visit(ctx.boundSpec().bound2().numericExpression().simpleExpression())
           end
           base_type = visit(ctx.entityRef()[0])
 
@@ -1091,11 +1063,11 @@ module Expressir
             base_type: base_type
           })
         elsif ctx.BAG()
-          bound1, bound2 = if ctx.boundSpec()
-            [
-              visit(ctx.boundSpec().bound1().numericExpression().simpleExpression()),
-              visit(ctx.boundSpec().bound2().numericExpression().simpleExpression())
-            ]
+          bound1 = if ctx.boundSpec()
+            visit(ctx.boundSpec().bound1().numericExpression().simpleExpression())
+          end
+          bound2 = if ctx.boundSpec()
+            visit(ctx.boundSpec().bound2().numericExpression().simpleExpression())
           end
           base_type = visit(ctx.entityRef()[0])
 
@@ -1107,27 +1079,24 @@ module Expressir
         else
           visit(ctx.entityRef()[0])
         end
-        attribute = if ctx.entityRef()[1]
+        expression = if ctx.entityRef()[1]
           ref = visit(ctx.entityRef()[1])
           attribute = visit(ctx.attributeRef())
-          attribute_qualifier = Model::Expressions::AttributeQualifier.new({
-            attribute: attribute
-          })
-          qualifiers = [attribute_qualifier]
 
-          Model::Expressions::QualifiedRef.new({
+          Model::Expressions::AttributeReference.new({
             ref: ref,
-            qualifiers: qualifiers
+            attribute: attribute
           })
         else
           visit(ctx.attributeRef())
         end
 
-        Model::Inverse.new({
-          id: id,
+        Model::Attribute.new({
+          kind: Model::Attribute::INVERSE,
           supertype_attribute: supertype_attribute,
+          id: id,
           type: type,
-          attribute: attribute
+          expression: expression
         })
       end
 
@@ -1136,11 +1105,11 @@ module Expressir
       end
 
       def visitListType(ctx)
-        bound1, bound2 = if ctx.boundSpec()
-          [
-            visit(ctx.boundSpec().bound1().numericExpression().simpleExpression()),
-            visit(ctx.boundSpec().bound2().numericExpression().simpleExpression())
-          ]
+        bound1 = if ctx.boundSpec()
+          visit(ctx.boundSpec().bound1().numericExpression().simpleExpression())
+        end
+        bound2 = if ctx.boundSpec()
+          visit(ctx.boundSpec().bound2().numericExpression().simpleExpression())
         end
         unique = !!ctx.UNIQUE()
         base_type = visit(ctx.instantiableType())
@@ -1181,7 +1150,7 @@ module Expressir
         end
 
         ids.map do |id|
-          Model::Local.new({
+          Model::Variable.new({
             id: id,
             type: type,
             expression: expression
@@ -1195,11 +1164,11 @@ module Expressir
 
       def visitLogicalLiteral(ctx)
         value = if ctx.TRUE()
-          true
+          Model::Literals::Logical::TRUE
         elsif ctx.FALSE()
-          false
+          Model::Literals::Logical::FALSE
         elsif ctx.UNKNOWN()
-          nil
+          Model::Literals::Logical::UNKNOWN
         else
           raise 'Invalid state'
         end
@@ -1215,17 +1184,17 @@ module Expressir
 
       def visitMultiplicationLikeOp(ctx)
         if ctx.text == '*'
-          Model::Operators::Multiplication.new()
+          Model::Expressions::BinaryExpression::MULTIPLICATION
         elsif ctx.text == '/'
-          Model::Operators::RealDivision.new()
+          Model::Expressions::BinaryExpression::REAL_DIVISION
         elsif ctx.DIV()
-          Model::Operators::IntegerDivision.new()
+          Model::Expressions::BinaryExpression::INTEGER_DIVISION
         elsif ctx.MOD()
-          Model::Operators::Modulo.new()
+          Model::Expressions::BinaryExpression::MODULO
         elsif ctx.AND()
-          Model::Operators::And.new()
+          Model::Expressions::BinaryExpression::AND
         elsif ctx.text == '||'
-          Model::Operators::Combine.new()
+          Model::Expressions::BinaryExpression::COMBINE
         else
           raise 'Invalid state'
         end
@@ -1272,12 +1241,12 @@ module Expressir
       end
 
       def visitOneOf(ctx)
-        operator = Model::Operators::Oneof.new()
-        operands = ctx.supertypeExpression().map{|ctx| visit(ctx)}
+        ref = Model::Expressions::SimpleReference.new({ id: 'ONEOF' })
+        parameters = ctx.supertypeExpression().map{|ctx| visit(ctx)}
 
-        Model::Expressions::Expression.new({
-          operator: operator,
-          operands: operands
+        Model::Expressions::Call.new({
+          ref: ref,
+          parameters: parameters
         })
       end
 
@@ -1313,14 +1282,14 @@ module Expressir
         if ctx.literal()
           visit(ctx.literal())
         elsif ctx.qualifiableFactor()
-          visit(ctx.qualifiableFactor())
+          handleQualifiedRef(visit(ctx.qualifiableFactor()), ctx.qualifier())
         else
           raise 'Invalid state'
         end
       end
 
       def visitProcedureCallStmt(ctx)
-        procedure = if ctx.builtInProcedure()
+        ref = if ctx.builtInProcedure()
           visit(ctx.builtInProcedure())
         elsif ctx.procedureRef()
           visit(ctx.procedureRef())
@@ -1331,8 +1300,8 @@ module Expressir
           ctx.actualParameterList().parameter().map{|ctx| visit(ctx.expression)}
         end
 
-        Model::Statements::ProcedureCall.new({
-          procedure: procedure,
+        Model::Statements::Call.new({
+          ref: ref,
           parameters: parameters
         })
       end
@@ -1346,9 +1315,9 @@ module Expressir
           if var.text == 'VAR'
             parameters.map do |parameter|
               Model::Parameter.new({
+                var: true,
                 id: parameter.id,
-                type: parameter.type,
-                var: true
+                type: parameter.type
               })
             end
           else
@@ -1359,7 +1328,7 @@ module Expressir
         constants = if ctx.algorithmHead().constantDecl()
           ctx.algorithmHead().constantDecl().constantBody().map{|ctx| visit(ctx)}
         end
-        locals = if ctx.algorithmHead().localDecl()
+        variables = if ctx.algorithmHead().localDecl()
           ctx.algorithmHead().localDecl().localVariable().map{|ctx| visit(ctx)}.flatten
         end
         statements = ctx.stmt().map{|ctx| visit(ctx)}
@@ -1369,7 +1338,7 @@ module Expressir
           parameters: parameters,
           declarations: declarations,
           constants: constants,
-          locals: locals,
+          variables: variables,
           statements: statements
         })
       end
@@ -1400,18 +1369,17 @@ module Expressir
 
       def visitQualifiedAttribute(ctx)
         id = ctx.SELF().text
-
-        ref = Model::Ref.new({
-          id: id
-        })
-
-        group_qualifier = visit(ctx.groupQualifier())
-        attribute_qualifier = visit(ctx.attributeQualifier())
-        qualifiers = [group_qualifier, attribute_qualifier]
-
-        Model::Expressions::QualifiedRef.new({
-          ref: ref,
-          qualifiers: qualifiers
+        entity = visit(ctx.groupQualifier().entityRef())
+        attribute = visit(ctx.attributeQualifier().attributeRef())
+
+        Model::Expressions::AttributeReference.new({
+          ref: Model::Expressions::GroupReference.new({
+            ref: Model::Expressions::SimpleReference.new({
+              id: id
+            }),
+            entity: entity
+          }),
+          attribute: attribute
         })
       end
 
@@ -1432,7 +1400,7 @@ module Expressir
         source = visit(ctx.aggregateSource().simpleExpression())
         expression = visit(ctx.logicalExpression().expression())
 
-        Model::Expressions::Query.new({
+        Model::Expressions::QueryExpression.new({
           id: id,
           source: source,
           expression: expression
@@ -1467,7 +1435,8 @@ module Expressir
         schema = visit(ctx.schemaRef())
         items = ctx.resourceOrRename().map{|ctx| visit(ctx)}
 
-        Model::Reference.new({
+        Model::Interface.new({
+          kind: Model::Interface::REFERENCE,
           schema: schema,
           items: items
         })
@@ -1475,21 +1444,21 @@ module Expressir
 
       def visitRelOp(ctx)
         if ctx.text == '<'
-          Model::Operators::LessThan.new()
+          Model::Expressions::BinaryExpression::LESS_THAN
         elsif ctx.text == '>'
-          Model::Operators::GreaterThan.new()
+          Model::Expressions::BinaryExpression::GREATER_THAN
         elsif ctx.text == '<='
-          Model::Operators::LessThanOrEqual.new()
+          Model::Expressions::BinaryExpression::LESS_THAN_OR_EQUAL
         elsif ctx.text == '>='
-          Model::Operators::GreaterThanOrEqual.new()
+          Model::Expressions::BinaryExpression::GREATER_THAN_OR_EQUAL
         elsif ctx.text == '<>'
-          Model::Operators::NotEqual.new()
+          Model::Expressions::BinaryExpression::NOT_EQUAL
         elsif ctx.text == '='
-          Model::Operators::Equal.new()
+          Model::Expressions::BinaryExpression::EQUAL
         elsif ctx.text == ':<>:'
-          Model::Operators::InstanceNotEqual.new()
+          Model::Expressions::BinaryExpression::INSTANCE_NOT_EQUAL
         elsif ctx.text == ':=:'
-          Model::Operators::InstanceEqual.new()
+          Model::Expressions::BinaryExpression::INSTANCE_EQUAL
         else
           raise 'Invalid state'
         end
@@ -1499,9 +1468,9 @@ module Expressir
         if ctx.relOp()
           visit(ctx.relOp())
         elsif ctx.IN()
-          Model::Operators::In.new()
+          Model::Expressions::BinaryExpression::IN
         elsif ctx.LIKE()
-          Model::Operators::Like.new()
+          Model::Expressions::BinaryExpression::LIKE
         else
           raise 'Invalid state'
         end
@@ -1531,11 +1500,11 @@ module Expressir
         id = if ctx.repeatControl().incrementControl()
           visit(ctx.repeatControl().incrementControl().variableId())
         end
-        bound1, bound2 = if ctx.repeatControl().incrementControl()
-          [
-            visit(ctx.repeatControl().incrementControl().bound1().numericExpression().simpleExpression()),
-            visit(ctx.repeatControl().incrementControl().bound2().numericExpression().simpleExpression())
-          ]
+        bound1 = if ctx.repeatControl().incrementControl()
+          visit(ctx.repeatControl().incrementControl().bound1().numericExpression().simpleExpression())
+        end
+        bound2 = if ctx.repeatControl().incrementControl()
+          visit(ctx.repeatControl().incrementControl().bound2().numericExpression().simpleExpression())
         end
         increment = if ctx.repeatControl().incrementControl() && ctx.repeatControl().incrementControl().increment()
           visit(ctx.repeatControl().incrementControl().increment().numericExpression().simpleExpression())
@@ -1594,7 +1563,9 @@ module Expressir
       end
 
       def visitReturnStmt(ctx)
-        expression = visit(ctx.expression())
+        expression = if ctx.expression()
+          visit(ctx.expression())
+        end
 
         Model::Statements::Return.new({
           expression: expression
@@ -1608,20 +1579,20 @@ module Expressir
         constants = if ctx.algorithmHead().constantDecl()
           ctx.algorithmHead().constantDecl().constantBody().map{|ctx| visit(ctx)}
         end
-        locals = if ctx.algorithmHead().localDecl()
+        variables = if ctx.algorithmHead().localDecl()
           ctx.algorithmHead().localDecl().localVariable().map{|ctx| visit(ctx)}.flatten
         end
-        where = ctx.whereClause().domainRule().map{|ctx| visit(ctx)}
         statements = ctx.stmt().map{|ctx| visit(ctx)}
+        where = ctx.whereClause().domainRule().map{|ctx| visit(ctx)}
 
         Model::Rule.new({
           id: id,
           applies_to: applies_to,
           declarations: declarations,
           constants: constants,
-          locals: locals,
-          where: where,
-          statements: statements
+          variables: variables,
+          statements: statements,
+          where: where
         })
       end
 
@@ -1650,16 +1621,17 @@ module Expressir
         constants = if ctx.schemaBody().constantDecl()
           ctx.schemaBody().constantDecl().constantBody().map{|ctx| visit(ctx)}
         end
-        declarations = ctx.schemaBody().declaration().map{|ctx| visit(ctx)}
-        rules = ctx.schemaBody().ruleDecl().map{|ctx| visit(ctx)}
+        declarations = [
+          *ctx.schemaBody().declaration().map{|ctx| visit(ctx)},
+          *ctx.schemaBody().ruleDecl().map{|ctx| visit(ctx)}
+        ]
 
         Model::Schema.new({
           id: id,
           version: version,
           interfaces: interfaces,
           constants: constants,
-          declarations: declarations,
-          rules: rules
+          declarations: declarations
         })
       end
 
@@ -1706,11 +1678,11 @@ module Expressir
       end
 
       def visitSetType(ctx)
-        bound1, bound2 = if ctx.boundSpec()
-          [
-            visit(ctx.boundSpec().bound1().numericExpression().simpleExpression()),
-            visit(ctx.boundSpec().bound2().numericExpression().simpleExpression())
-          ]
+        bound1 = if ctx.boundSpec()
+          visit(ctx.boundSpec().bound1().numericExpression().simpleExpression())
+        end
+        bound2 = if ctx.boundSpec()
+          visit(ctx.boundSpec().bound2().numericExpression().simpleExpression())
         end
         base_type = visit(ctx.instantiableType())
         
@@ -1751,17 +1723,17 @@ module Expressir
           operator = visit(ctx.unaryOp())
           operand = visit(ctx.expression())
 
-          Model::Expressions::Expression.new({
+          Model::Expressions::UnaryExpression.new({
             operator: operator,
-            operands: [operand]
+            operand: operand
           })
         elsif ctx.unaryOp() && ctx.primary()
           operator = visit(ctx.unaryOp())
           operand = visit(ctx.primary())
 
-          Model::Expressions::Expression.new({
+          Model::Expressions::UnaryExpression.new({
             operator: operator,
-            operands: [operand]
+            operand: operand
           })
         else
           raise 'Invalid state'
@@ -1859,20 +1831,20 @@ module Expressir
       def visitSubtypeConstraintDecl(ctx)
         id = visit(ctx.subtypeConstraintHead().subtypeConstraintId())
         applies_to = visit(ctx.subtypeConstraintHead().entityRef())
-        abstract_supertype = !!ctx.subtypeConstraintBody().abstractSupertype()
+        abstract = !!ctx.subtypeConstraintBody().abstractSupertype()
         total_over = if ctx.subtypeConstraintBody().totalOver()
           ctx.subtypeConstraintBody().totalOver().entityRef().map{|ctx| visit(ctx)}
         end
-        subtype_expression = if ctx.subtypeConstraintBody().supertypeExpression()
+        supertype_expression = if ctx.subtypeConstraintBody().supertypeExpression()
           visit(ctx.subtypeConstraintBody().supertypeExpression())
         end
 
         Model::SubtypeConstraint.new({
           id: id,
           applies_to: applies_to,
-          abstract_supertype: abstract_supertype,
+          abstract: abstract,
           total_over: total_over,
-          subtype_expression: subtype_expression
+          supertype_expression: supertype_expression
         })
       end
 
@@ -1895,7 +1867,7 @@ module Expressir
       def visitSupertypeExpression(ctx)
         if ctx.supertypeFactor().length >= 2
           operands = ctx.supertypeFactor().map{|ctx| visit(ctx)}
-          operators = ctx.ANDOR().map{|ctx| Model::Operators::Andor.new()}
+          operators = ctx.ANDOR().map{|ctx| Model::Expressions::BinaryExpression::ANDOR}
 
           handleBinaryExpression(operands, operators)
         else
@@ -1906,7 +1878,7 @@ module Expressir
       def visitSupertypeFactor(ctx)
         if ctx.supertypeTerm().length >= 2
           operands = ctx.supertypeTerm().map{|ctx| visit(ctx)}
-          operators = ctx.AND().map{|ctx| Model::Operators::And.new()}
+          operators = ctx.AND().map{|ctx| Model::Expressions::BinaryExpression::AND}
 
           handleBinaryExpression(operands, operators)
         else
@@ -1987,11 +1959,11 @@ module Expressir
 
       def visitUnaryOp(ctx)
         if ctx.text == '+'
-          Model::Operators::UnaryPlus.new()
+          Model::Expressions::UnaryExpression::PLUS
         elsif ctx.text == '-'
-          Model::Operators::UnaryMinus.new()
+          Model::Expressions::UnaryExpression::MINUS
         elsif ctx.NOT()
-          Model::Operators::Not.new()
+          Model::Expressions::UnaryExpression::NOT
         else
           raise 'Invalid state'
         end
@@ -2031,7 +2003,8 @@ module Expressir
         schema = visit(ctx.schemaRef())
         items = ctx.namedTypeOrRename().map{|ctx| visit(ctx)}
 
-        Model::Use.new({
+        Model::Interface.new({
+          kind: Model::Interface::USE,
           schema: schema,
           items: items
         })
@@ -2072,19 +2045,54 @@ module Expressir
           raise 'Invalid state'
         end
 
-        expression = Model::Expressions::Expression.new({
+        expression = Model::Expressions::BinaryExpression.new({
           operator: operators[0],
-          operands: [operands[0], operands[1]]
+          operand1: operands[0],
+          operand2: operands[1]
         })
         operators[1..(operators.length - 1)].each_with_index do |operator, i|
-          expression = Model::Expressions::Expression.new({
+          expression = Model::Expressions::BinaryExpression.new({
             operator: operator,
-            operands: [expression, operands[i + 2]]
+            operand1: expression,
+            operand2: operands[i + 2]
           })
         end
         expression
       end
 
+      def handleQualifiedRef(ref, qualifiers)
+        qualifiers.reduce(ref) do |ref, ctx|
+          if ctx.attributeQualifier()
+            attribute = visit(ctx.attributeQualifier().attributeRef())
+
+            Model::Expressions::AttributeReference.new({
+              ref: ref,
+              attribute: attribute
+            })
+          elsif ctx.groupQualifier()
+            entity = visit(ctx.groupQualifier().entityRef())
+
+            Model::Expressions::GroupReference.new({
+              ref: ref,
+              entity: entity
+            })
+          elsif ctx.indexQualifier()
+            index1 = visit(ctx.indexQualifier().index1().index().numericExpression().simpleExpression())
+            index2 = if ctx.indexQualifier().index2()
+              visit(ctx.indexQualifier().index2().index().numericExpression().simpleExpression())
+            end
+
+            Model::Expressions::IndexReference.new({
+              ref: ref,
+              index1: index1,
+              index2: index2
+            })
+          else
+            raise 'Invalid state'
+          end
+        end
+      end
+
       def handleBinaryLiteral(ctx)
         value = ctx.text[1..(ctx.text.length - 1)]