puppet 4.10.12-x64-mingw32 → 5.0.0-x64-mingw32

data/spec/unit/parser/scope_spec.rb

@@ -247,9 +247,9 @@ describe Puppet::Parser::Scope do
         @scope.class_scope(klass)
       end
 
-      it "should be able to look up explicitly fully qualified variables from main" do
+      it "should be able to look up explicitly fully qualified variables from compiler's top scope" do
         Puppet.expects(:deprecation_warning).never
-        other_scope = create_class_scope("")
+        other_scope = @scope.compiler.topscope
 
         other_scope["othervar"] = "otherval"
 
@@ -367,59 +367,13 @@ describe Puppet::Parser::Scope do
     end
   end
 
-  describe "when variables are set with append=true" do
-    it "should raise error if the variable is already defined in this scope" do
-      @scope.setvar("var", "1", :append => false)
-      expect {
-        @scope.setvar("var", "1", :append => true)
-      }.to raise_error(
-        Puppet::ParseError,
-        "Cannot append, variable '$var' is defined in this scope"
-      )
-    end
-
-    it "should lookup current variable value" do
-      @scope.expects(:[]).with("var").returns("2")
-      @scope.setvar("var", "1", :append => true)
-    end
-
-    it "should store the concatenated string '42'" do
-      @topscope.setvar("var", "4", :append => false)
-      @scope.setvar("var", "2", :append => true)
-      expect(@scope["var"]).to eq("42")
-    end
-
-    it "should store the concatenated array [4,2]" do
-      @topscope.setvar("var", [4], :append => false)
-      @scope.setvar("var", [2], :append => true)
-      expect(@scope["var"]).to eq([4,2])
-    end
-
-    it "should store the merged hash {a => b, c => d}" do
-      @topscope.setvar("var", {"a" => "b"}, :append => false)
-      @scope.setvar("var", {"c" => "d"}, :append => true)
-      expect(@scope["var"]).to eq({"a" => "b", "c" => "d"})
-    end
-
-    it "should raise an error when appending a hash with something other than another hash" do
-      @topscope.setvar("var", {"a" => "b"}, :append => false)
-
-      expect {
-        @scope.setvar("var", "not a hash", :append => true)
-      }.to raise_error(
-        ArgumentError,
-        "Trying to append to a hash with something which is not a hash is unsupported"
-      )
-    end
-  end
-
   describe "when calling number?" do
     it "should return nil if called with anything not a number" do
       expect(Puppet::Parser::Scope.number?([2])).to be_nil
     end
 
-    it "should return a Fixnum for a Fixnum" do
-      expect(Puppet::Parser::Scope.number?(2)).to be_an_instance_of(Fixnum)
+    it "should return a Integer for an Integer" do
+      expect(Puppet::Parser::Scope.number?(2)).to be_a(Integer)
     end
 
     it "should return a Float for a Float" do
@@ -477,31 +431,10 @@ describe Puppet::Parser::Scope do
 
   describe "when using ephemeral variables" do
     it "should store the variable value" do
-#      @scope.setvar("1", :value, :ephemeral => true)
       @scope.set_match_data({1 => :value})
       expect(@scope["1"]).to eq(:value)
     end
 
-    it "should remove the variable value when unset_ephemeral_var(:all) is called" do
-#      @scope.setvar("1", :value, :ephemeral => true)
-      @scope.set_match_data({1 => :value})
-      @scope.stubs(:parent).returns(nil)
-
-      @scope.unset_ephemeral_var(:all)
-
-      expect(@scope["1"]).to be_nil
-    end
-
-    it "should not remove classic variables when unset_ephemeral_var(:all) is called" do
-      @scope['myvar'] = :value1
-      @scope.set_match_data({1 => :value2})
-      @scope.stubs(:parent).returns(nil)
-
-      @scope.unset_ephemeral_var(:all)
-
-      expect(@scope["myvar"]).to eq(:value1)
-    end
-
     it "should raise an error when setting numerical variable" do
       expect {
         @scope.setvar("1", :value3, :ephemeral => true)
@@ -523,8 +456,6 @@ describe Puppet::Parser::Scope do
       end
 
       it "should not check presence of an ephemeral variable across multiple levels" do
-        # This test was testing that scope actuallys screwed up - making values from earlier matches show as if they
-        # where true for latest match - insanity !
         @scope.new_ephemeral
         @scope.set_match_data({1 => :value1})
         @scope.new_ephemeral
@@ -571,14 +502,6 @@ describe Puppet::Parser::Scope do
       expect(@scope["apple"]).to eq(:fruit)
     end
 
-    it "should remove all local scope variables on unset" do
-      @scope.new_ephemeral true
-      @scope.setvar("apple", :fruit)
-      expect(@scope["apple"]).to eq(:fruit)
-      @scope.unset_ephemeral_var
-      expect(@scope["apple"]).to eq(nil)
-    end
-
     it 'should store an undef in local scope and let it override parent scope' do
       @scope['cloaked'] = 'Cloak me please'
       @scope.new_ephemeral(true)

data/spec/unit/pops/benchmark_spec.rb

@@ -4,11 +4,6 @@ require 'puppet/pops'
 require 'puppet_spec/pops'
 require 'puppet_spec/scope'
 
-require 'rgen/environment'
-require 'rgen/metamodel_builder'
-require 'rgen/serializer/json_serializer'
-require 'rgen/instantiator/json_instantiator'
-
 describe "Benchmark", :benchmark => true do
   include PuppetSpec::Pops
   include PuppetSpec::Scope
@@ -28,30 +23,17 @@ $a = "interpolate ${foo} and stuff"
     alias write concat
   end
 
-  class MyJSonSerializer < RGen::Serializer::JsonSerializer
-    def attributeValue(value, a)
-      x = super
-      puts "#{a.eType} value: <<#{value}>> serialize: <<#{x}>>"
-      x
-    end
-  end
-
   def json_dump(model)
     output = StringWriter.new
-    ser = MyJSonSerializer.new(output)
-    ser.serialize(model)
+    ser = Puppet::Pops::Serialization::Serializer.new(Puppet::Pops::Serialization::JSON.writer.new(output))
+    ser.write(model)
+    ser.finish
     output
   end
 
-  def json_load(string)
-    env = RGen::Environment.new
-    inst = RGen::Instantiator::JsonInstantiator.new(env, Puppet::Pops::Model)
-    inst.instantiate(string)
-  end
-
   it "transformer", :profile => true do
     parser = Puppet::Pops::Parser::Parser.new()
-    model = parser.parse_string(code).current
+    model = parser.parse_string(code).model
     transformer = Puppet::Pops::Model::AstTransformer.new()
     m = Benchmark.measure { 10000.times { transformer.transform(model) }}
     puts "Transformer: #{m}"
@@ -67,7 +49,7 @@ $a = "interpolate ${foo} and stuff"
   it "parse transform", :profile => true do
     parser = Puppet::Pops::Parser::Parser.new()
     transformer = Puppet::Pops::Model::AstTransformer.new()
-    m = Benchmark.measure { 10000.times { transformer.transform(parser.parse_string(code).current) }}
+    m = Benchmark.measure { 10000.times { transformer.transform(parser.parse_string(code).model) }}
     puts "Parse and transform: #{m}"
   end
 
@@ -85,7 +67,7 @@ $a = "interpolate ${foo} and stuff"
 
   it "marshal1", :profile => true do
     parser = Puppet::Pops::Parser::EvaluatingParser.new()
-    model = parser.parse_string(code).current
+    model = parser.parse_string(code).model
     dumped = Marshal.dump(model)
     m = Benchmark.measure { 10000.times { Marshal.load(dumped) }}
     puts "Marshal1: #{m}"
@@ -93,10 +75,10 @@ $a = "interpolate ${foo} and stuff"
 
   it "rgenjson", :profile => true do
     parser = Puppet::Pops::Parser::EvaluatingParser.new()
-    model = parser.parse_string(code).current
+    model = parser.parse_string(code).model
     dumped = json_dump(model)
     m = Benchmark.measure { 10000.times { json_load(dumped) }}
-    puts "RGen Json: #{m}"
+    puts "Pcore Json: #{m}"
   end
 
   it "lexer2", :profile => true do

data/spec/unit/pops/containment_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-require File.join(File.dirname(__FILE__), 'factory_rspec_helper')
-
-describe Puppet::Pops::Containment do
-  include FactoryRspecHelper
-
-  it "Should return an Enumerable if eAllContents is called without arguments" do
-    expect((literal(1) + literal(2)).current.eAllContents.is_a?(Enumerable)).to eq(true)
-  end
-
-  it "Should return all content" do
-    # Note the top object is not included (an ArithmeticOperation with + operator)
-    expect((literal(1) + literal(2) + literal(3)).current.eAllContents.collect {|x| x}.size).to eq(4)
-  end
-
-  it "Should return containing feature" do
-    left = literal(1)
-    right = literal(2)
-    op = left + right
-
-    #pending "eContainingFeature does not work on _uni containments in RGen < 0.6.1"
-    expect(left.current.eContainingFeature).to eq(:left_expr)
-    expect(right.current.eContainingFeature).to eq(:right_expr)
-  end
-end

data/spec/unit/pops/evaluator/access_ops_spec.rb

@@ -24,115 +24,115 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
     # Note that the factory is not aware of Binary and cannot operate on a
     # literal binary. Instead, it must create a call to Binary.new() with the base64 encoded
     # string as an argument
-    CALL_NAMED(QREF("Binary"), true, [Base64.strict_encode64(s)])
+    CALL_NAMED(QREF("Binary"), true, [infer(Base64.strict_encode64(s))])
   end
 
   context 'The evaluator when operating on a String' do
     it 'can get a single character using a single key index to []' do
-      expect(evaluate(literal('abc')[1])).to eql('b')
+      expect(evaluate(literal('abc').access_at(1))).to eql('b')
     end
 
     it 'can get the last character using the key -1 in []' do
-      expect(evaluate(literal('abc')[-1])).to eql('c')
+      expect(evaluate(literal('abc').access_at(-1))).to eql('c')
     end
 
     it 'can get a substring by giving two keys' do
-      expect(evaluate(literal('abcd')[1,2])).to eql('bc')
+      expect(evaluate(literal('abcd').access_at(1,2))).to eql('bc')
       # flattens keys
-      expect(evaluate(literal('abcd')[[1,2]])).to eql('bc')
+      expect(evaluate(literal('abcd').access_at([1,2]))).to eql('bc')
     end
 
     it 'produces empty string for a substring out of range' do
-      expect(evaluate(literal('abc')[100])).to eql('')
+      expect(evaluate(literal('abc').access_at(100))).to eql('')
     end
 
     it 'raises an error if arity is wrong for []' do
-      expect{evaluate(literal('abc')[])}.to raise_error(/String supports \[\] with one or two arguments\. Got 0/)
-      expect{evaluate(literal('abc')[1,2,3])}.to raise_error(/String supports \[\] with one or two arguments\. Got 3/)
+      expect{evaluate(literal('abc').access_at)}.to raise_error(/String supports \[\] with one or two arguments\. Got 0/)
+      expect{evaluate(literal('abc').access_at(1,2,3))}.to raise_error(/String supports \[\] with one or two arguments\. Got 3/)
     end
   end
 
   context 'The evaluator when operating on a Binary' do
     it 'can get a single character using a single key index to []' do
-      expect(evaluate(binary('abc')[1]).binary_buffer).to eql('b')
+      expect(evaluate(binary('abc').access_at(1)).binary_buffer).to eql('b')
     end
 
     it 'can get the last character using the key -1 in []' do
-      expect(evaluate(binary('abc')[-1]).binary_buffer).to eql('c')
+      expect(evaluate(binary('abc').access_at(-1)).binary_buffer).to eql('c')
     end
 
     it 'can get a substring by giving two keys' do
-      expect(evaluate(binary('abcd')[1,2]).binary_buffer).to eql('bc')
+      expect(evaluate(binary('abcd').access_at(1,2)).binary_buffer).to eql('bc')
       # flattens keys
-      expect(evaluate(binary('abcd')[[1,2]]).binary_buffer).to eql('bc')
+      expect(evaluate(binary('abcd').access_at([1,2])).binary_buffer).to eql('bc')
     end
 
     it 'produces empty string for a substring out of range' do
-      expect(evaluate(binary('abc')[100]).binary_buffer).to eql('')
+      expect(evaluate(binary('abc').access_at(100)).binary_buffer).to eql('')
     end
 
     it 'raises an error if arity is wrong for []' do
-      expect{evaluate(binary('abc')[])}.to raise_error(/String supports \[\] with one or two arguments\. Got 0/)
-      expect{evaluate(binary('abc')[1,2,3])}.to raise_error(/String supports \[\] with one or two arguments\. Got 3/)
+      expect{evaluate(binary('abc').access_at)}.to raise_error(/String supports \[\] with one or two arguments\. Got 0/)
+      expect{evaluate(binary('abc').access_at(1,2,3))}.to raise_error(/String supports \[\] with one or two arguments\. Got 3/)
     end
   end
 
   context 'The evaluator when operating on an Array' do
     it 'is tested with the correct assumptions' do
-      expect(literal([1,2,3])[1].current.is_a?(Puppet::Pops::Model::AccessExpression)).to eql(true)
+      expect(literal([1,2,3]).access_at(1).model_class <= Puppet::Pops::Model::AccessExpression).to eql(true)
     end
 
     it 'can get an element using a single key index to []' do
-      expect(evaluate(literal([1,2,3])[1])).to eql(2)
+      expect(evaluate(literal([1,2,3]).access_at(1))).to eql(2)
     end
 
     it 'can get the last element using the key -1 in []' do
-      expect(evaluate(literal([1,2,3])[-1])).to eql(3)
+      expect(evaluate(literal([1,2,3]).access_at(-1))).to eql(3)
     end
 
     it 'can get a slice of elements using two keys' do
-      expect(evaluate(literal([1,2,3,4])[1,2])).to eql([2,3])
+      expect(evaluate(literal([1,2,3,4]).access_at(1,2))).to eql([2,3])
       # flattens keys
-      expect(evaluate(literal([1,2,3,4])[[1,2]])).to eql([2,3])
+      expect(evaluate(literal([1,2,3,4]).access_at([1,2]))).to eql([2,3])
     end
 
     it 'produces nil for a missing entry' do
-      expect(evaluate(literal([1,2,3])[100])).to eql(nil)
+      expect(evaluate(literal([1,2,3]).access_at(100))).to eql(nil)
     end
 
     it 'raises an error if arity is wrong for []' do
-      expect{evaluate(literal([1,2,3,4])[])}.to raise_error(/Array supports \[\] with one or two arguments\. Got 0/)
-      expect{evaluate(literal([1,2,3,4])[1,2,3])}.to raise_error(/Array supports \[\] with one or two arguments\. Got 3/)
+      expect{evaluate(literal([1,2,3,4]).access_at)}.to raise_error(/Array supports \[\] with one or two arguments\. Got 0/)
+      expect{evaluate(literal([1,2,3,4]).access_at(1,2,3))}.to raise_error(/Array supports \[\] with one or two arguments\. Got 3/)
     end
   end
 
   context 'The evaluator when operating on a Hash' do
     it 'can get a single element giving a single key to []' do
-      expect(evaluate(literal({'a'=>1,'b'=>2,'c'=>3})['b'])).to eql(2)
+      expect(evaluate(literal({'a'=>1,'b'=>2,'c'=>3}).access_at('b'))).to eql(2)
     end
 
     it 'can lookup an array' do
-      expect(evaluate(literal({[1]=>10,[2]=>20})[[2]])).to eql(20)
+      expect(evaluate(literal({[1]=>10,[2]=>20}).access_at([2]))).to eql(20)
     end
 
     it 'produces nil for a missing key' do
-      expect(evaluate(literal({'a'=>1,'b'=>2,'c'=>3})['x'])).to eql(nil)
+      expect(evaluate(literal({'a'=>1,'b'=>2,'c'=>3}).access_at('x'))).to eql(nil)
     end
 
     it 'can get multiple elements by giving multiple keys to []' do
-      expect(evaluate(literal({'a'=>1,'b'=>2,'c'=>3, 'd'=>4})['b', 'd'])).to eql([2, 4])
+      expect(evaluate(literal({'a'=>1,'b'=>2,'c'=>3, 'd'=>4}).access_at('b', 'd'))).to eql([2, 4])
     end
 
     it 'compacts the result when using multiple keys' do
-      expect(evaluate(literal({'a'=>1,'b'=>2,'c'=>3, 'd'=>4})['b', 'x'])).to eql([2])
+      expect(evaluate(literal({'a'=>1,'b'=>2,'c'=>3, 'd'=>4}).access_at('b', 'x'))).to eql([2])
     end
 
     it 'produces an empty array if none of multiple given keys were missing' do
-      expect(evaluate(literal({'a'=>1,'b'=>2,'c'=>3, 'd'=>4})['x', 'y'])).to eql([])
+      expect(evaluate(literal({'a'=>1,'b'=>2,'c'=>3, 'd'=>4}).access_at('x', 'y'))).to eql([])
     end
 
     it 'raises an error if arity is wrong for []' do
-      expect{evaluate(literal({'a'=>1,'b'=>2,'c'=>3})[])}.to raise_error(/Hash supports \[\] with one or more arguments\. Got 0/)
+      expect{evaluate(literal({'a'=>1,'b'=>2,'c'=>3}).access_at)}.to raise_error(/Hash supports \[\] with one or more arguments\. Got 0/)
     end
   end
 
@@ -142,187 +142,187 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
     # Integer
     #
     it 'produces an Integer[from, to]' do
-      expr = fqr('Integer')[1, 3]
+      expr = fqr('Integer').access_at(1, 3)
       expect(evaluate(expr)).to eql(range(1,3))
 
       # arguments are flattened
-      expr = fqr('Integer')[[1, 3]]
+      expr = fqr('Integer').access_at([1, 3])
       expect(evaluate(expr)).to eql(range(1,3))
     end
 
     it 'produces an Integer[1]' do
-      expr = fqr('Integer')[1]
+      expr = fqr('Integer').access_at(1)
       expect(evaluate(expr)).to eql(range(1,:default))
     end
 
     it 'gives an error for Integer[from, <from]' do
-      expr = fqr('Integer')[1,0]
+      expr = fqr('Integer').access_at(1,0)
       expect{evaluate(expr)}.to raise_error(/'from' must be less or equal to 'to'/)
     end
 
     it 'produces an error for Integer[] if there are more than 2 keys' do
-      expr = fqr('Integer')[1,2,3]
+      expr = fqr('Integer').access_at(1,2,3)
       expect { evaluate(expr)}.to raise_error(/with one or two arguments/)
     end
 
     # Float
     #
     it 'produces a Float[from, to]' do
-      expr = fqr('Float')[1, 3]
+      expr = fqr('Float').access_at(1, 3)
       expect(evaluate(expr)).to eql(float_range(1.0,3.0))
 
       # arguments are flattened
-      expr = fqr('Float')[[1, 3]]
+      expr = fqr('Float').access_at([1, 3])
       expect(evaluate(expr)).to eql(float_range(1.0,3.0))
     end
 
     it 'produces a Float[1.0]' do
-      expr = fqr('Float')[1.0]
+      expr = fqr('Float').access_at(1.0)
       expect(evaluate(expr)).to eql(float_range(1.0,:default))
     end
 
     it 'produces a Float[1]' do
-      expr = fqr('Float')[1]
+      expr = fqr('Float').access_at(1)
       expect(evaluate(expr)).to eql(float_range(1.0,:default))
     end
 
     it 'gives an error for Float[from, <from]' do
-      expr = fqr('Float')[1.0,0.0]
+      expr = fqr('Float').access_at(1.0,0.0)
       expect{evaluate(expr)}.to raise_error(/'from' must be less or equal to 'to'/)
     end
 
     it 'produces an error for Float[] if there are more than 2 keys' do
-      expr = fqr('Float')[1,2,3]
+      expr = fqr('Float').access_at(1,2,3)
       expect { evaluate(expr)}.to raise_error(/with one or two arguments/)
     end
 
     # Hash Type
     #
     it 'produces a Hash[0, 0] from the expression Hash[0, 0]' do
-      expr = fqr('Hash')[0, 0]
+      expr = fqr('Hash').access_at(0, 0)
       expect(evaluate(expr)).to be_the_type(types.hash_of(types.default, types.default, types.range(0, 0)))
     end
 
     it 'produces a Hash[Scalar,String] from the expression Hash[Scalar, String]' do
-      expr = fqr('Hash')[fqr('Scalar'), fqr('String')]
+      expr = fqr('Hash').access_at(fqr('Scalar'), fqr('String'))
       expect(evaluate(expr)).to be_the_type(types.hash_of(types.string, types.scalar))
 
       # arguments are flattened
-      expr = fqr('Hash')[[fqr('Scalar'), fqr('String')]]
+      expr = fqr('Hash').access_at([fqr('Scalar'), fqr('String')])
       expect(evaluate(expr)).to be_the_type(types.hash_of(types.string, types.scalar))
     end
 
     it 'gives an error if only one type is specified ' do
-      expr = fqr('Hash')[fqr('String')]
+      expr = fqr('Hash').access_at(fqr('String'))
       expect {evaluate(expr)}.to raise_error(/accepts 2 to 4 arguments/)
     end
 
     it 'produces a Hash[Scalar,String] from the expression Hash[Integer, Array][Integer, String]' do
-      expr = fqr('Hash')[fqr('Integer'), fqr('Array')][fqr('Integer'), fqr('String')]
+      expr = fqr('Hash').access_at(fqr('Integer'), fqr('Array')).access_at(fqr('Integer'), fqr('String'))
       expect(evaluate(expr)).to be_the_type(types.hash_of(types.string, types.integer))
     end
 
     it "gives an error if parameter is not a type" do
-      expr = fqr('Hash')['String']
+      expr = fqr('Hash').access_at('String')
       expect { evaluate(expr)}.to raise_error(/Hash-Type\[\] arguments must be types/)
     end
 
     # Array Type
     #
     it 'produces an Array[0, 0] from the expression Array[0, 0]' do
-      expr = fqr('Array')[0, 0]
+      expr = fqr('Array').access_at(0, 0)
       expect(evaluate(expr)).to be_the_type(types.array_of(types.default, types.range(0, 0)))
 
       # arguments are flattened
-      expr = fqr('Array')[[fqr('String')]]
+      expr = fqr('Array').access_at([fqr('String')])
       expect(evaluate(expr)).to be_the_type(types.array_of(types.string))
     end
 
     it 'produces an Array[String] from the expression Array[String]' do
-      expr = fqr('Array')[fqr('String')]
+      expr = fqr('Array').access_at(fqr('String'))
       expect(evaluate(expr)).to be_the_type(types.array_of(types.string))
 
       # arguments are flattened
-      expr = fqr('Array')[[fqr('String')]]
+      expr = fqr('Array').access_at([fqr('String')])
       expect(evaluate(expr)).to be_the_type(types.array_of(types.string))
     end
 
     it 'produces an Array[String] from the expression Array[Integer][String]' do
-      expr = fqr('Array')[fqr('Integer')][fqr('String')]
+      expr = fqr('Array').access_at(fqr('Integer')).access_at(fqr('String'))
       expect(evaluate(expr)).to be_the_type(types.array_of(types.string))
     end
 
     it 'produces a size constrained Array when the last two arguments specify this' do
-      expr = fqr('Array')[fqr('String'), 1]
+      expr = fqr('Array').access_at(fqr('String'), 1)
       expected_t = types.array_of(String, types.range(1, :default))
       expect(evaluate(expr)).to be_the_type(expected_t)
 
-      expr = fqr('Array')[fqr('String'), 1, 2]
+      expr = fqr('Array').access_at(fqr('String'), 1, 2)
       expected_t = types.array_of(String, types.range(1, 2))
       expect(evaluate(expr)).to be_the_type(expected_t)
     end
 
     it "Array parameterization gives an error if parameter is not a type" do
-      expr = fqr('Array')['String']
+      expr = fqr('Array').access_at('String')
       expect { evaluate(expr)}.to raise_error(/Array-Type\[\] arguments must be types/)
     end
 
     # Timespan Type
     #
     it 'produdes a Timespan type with a lower bound' do
-      expr = fqr('Timespan')[{fqn('hours') => literal(3)}]
+      expr = fqr('Timespan').access_at({fqn('hours') => literal(3)})
       expect(evaluate(expr)).to be_the_type(types.timespan({'hours' => 3}))
     end
 
     it 'produdes a Timespan type with an upper bound' do
-      expr = fqr('Timespan')[literal(:default), {fqn('hours') => literal(9)}]
+      expr = fqr('Timespan').access_at(literal(:default), {fqn('hours') => literal(9)})
       expect(evaluate(expr)).to be_the_type(types.timespan(nil, {'hours' => 9}))
     end
 
     it 'produdes a Timespan type with both lower and upper bounds' do
-      expr = fqr('Timespan')[{fqn('hours') => literal(3)}, {fqn('hours') => literal(9)}]
+      expr = fqr('Timespan').access_at({fqn('hours') => literal(3)}, {fqn('hours') => literal(9)})
       expect(evaluate(expr)).to be_the_type(types.timespan({'hours' => 3}, {'hours' => 9}))
     end
 
     # Timestamp Type
     #
     it 'produdes a Timestamp type with a lower bound' do
-      expr = fqr('Timestamp')[literal('2014-12-12T13:14:15 CET')]
+      expr = fqr('Timestamp').access_at(literal('2014-12-12T13:14:15 CET'))
       expect(evaluate(expr)).to be_the_type(types.timestamp('2014-12-12T13:14:15 CET'))
     end
 
     it 'produdes a Timestamp type with an upper bound' do
-      expr = fqr('Timestamp')[literal(:default), literal('2016-08-23T17:50:00 CET')]
+      expr = fqr('Timestamp').access_at(literal(:default), literal('2016-08-23T17:50:00 CET'))
       expect(evaluate(expr)).to be_the_type(types.timestamp(nil, '2016-08-23T17:50:00 CET'))
     end
 
     it 'produdes a Timestamp type with both lower and upper bounds' do
-      expr = fqr('Timestamp')[literal('2014-12-12T13:14:15 CET'), literal('2016-08-23T17:50:00 CET')]
+      expr = fqr('Timestamp').access_at(literal('2014-12-12T13:14:15 CET'), literal('2016-08-23T17:50:00 CET'))
       expect(evaluate(expr)).to be_the_type(types.timestamp('2014-12-12T13:14:15 CET', '2016-08-23T17:50:00 CET'))
     end
 
     # Tuple Type
     #
     it 'produces a Tuple[String] from the expression Tuple[String]' do
-      expr = fqr('Tuple')[fqr('String')]
+      expr = fqr('Tuple').access_at(fqr('String'))
       expect(evaluate(expr)).to be_the_type(types.tuple([String]))
 
       # arguments are flattened
-      expr = fqr('Tuple')[[fqr('String')]]
+      expr = fqr('Tuple').access_at([fqr('String')])
       expect(evaluate(expr)).to be_the_type(types.tuple([String]))
     end
 
     it "Tuple parameterization gives an error if parameter is not a type" do
-      expr = fqr('Tuple')['String']
+      expr = fqr('Tuple').access_at('String')
       expect { evaluate(expr)}.to raise_error(/Tuple-Type, Cannot use String where Any-Type is expected/)
     end
 
     it 'produces a varargs Tuple when the last two arguments specify size constraint' do
-      expr = fqr('Tuple')[fqr('String'), 1]
+      expr = fqr('Tuple').access_at(fqr('String'), 1)
       expected_t = types.tuple([String], types.range(1, :default))
       expect(evaluate(expr)).to be_the_type(expected_t)
 
-      expr = fqr('Tuple')[fqr('String'), 1, 2]
+      expr = fqr('Tuple').access_at(fqr('String'), 1, 2)
       expected_t = types.tuple([String], types.range(1, 2))
       expect(evaluate(expr)).to be_the_type(expected_t)
     end
@@ -330,116 +330,116 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
     # Pattern Type
     #
     it 'creates a PPatternType instance when applied to a Pattern' do
-      regexp_expr = fqr('Pattern')['foo']
+      regexp_expr = fqr('Pattern').access_at('foo')
       expect(evaluate(regexp_expr)).to eql(Puppet::Pops::Types::TypeFactory.pattern('foo'))
     end
 
     # Regexp Type
     #
     it 'creates a Regexp instance when applied to a Pattern' do
-      regexp_expr = fqr('Regexp')['foo']
+      regexp_expr = fqr('Regexp').access_at('foo')
       expect(evaluate(regexp_expr)).to eql(Puppet::Pops::Types::TypeFactory.regexp('foo'))
 
       # arguments are flattened
-      regexp_expr = fqr('Regexp')[['foo']]
+      regexp_expr = fqr('Regexp').access_at(['foo'])
       expect(evaluate(regexp_expr)).to eql(Puppet::Pops::Types::TypeFactory.regexp('foo'))
     end
 
     # Class
     #
     it 'produces a specific class from Class[classname]' do
-      expr = fqr('Class')[fqn('apache')]
+      expr = fqr('Class').access_at(fqn('apache'))
       expect(evaluate(expr)).to be_the_type(types.host_class('apache'))
-      expr = fqr('Class')[literal('apache')]
+      expr = fqr('Class').access_at(literal('apache'))
       expect(evaluate(expr)).to be_the_type(types.host_class('apache'))
     end
 
     it 'produces an array of Class when args are in an array' do
       # arguments are flattened
-      expr = fqr('Class')[[fqn('apache')]]
+      expr = fqr('Class').access_at([fqn('apache')])
       expect(evaluate(expr)[0]).to be_the_type(types.host_class('apache'))
     end
 
     it 'produces undef for Class if arg is undef' do
       # arguments are flattened
-      expr = fqr('Class')[nil]
+      expr = fqr('Class').access_at(nil)
       expect(evaluate(expr)).to be_nil
     end
 
     it 'produces empty array for Class if arg is [undef]' do
       # arguments are flattened
-      expr = fqr('Class')[[]]
+      expr = fqr('Class').access_at([])
       expect(evaluate(expr)).to be_eql([])
-      expr = fqr('Class')[[nil]]
+      expr = fqr('Class').access_at([nil])
       expect(evaluate(expr)).to be_eql([])
     end
 
     it 'raises error if access is to no keys' do
-      expr = fqr('Class')[fqn('apache')][]
+      expr = fqr('Class').access_at(fqn('apache')).access_at
       expect { evaluate(expr) }.to raise_error(/Evaluation Error: Class\[apache\]\[\] accepts 1 or more arguments\. Got 0/)
     end
 
     it 'produces a collection of classes when multiple class names are given' do
-      expr = fqr('Class')[fqn('apache'), literal('nginx')]
+      expr = fqr('Class').access_at(fqn('apache'), literal('nginx'))
       result = evaluate(expr)
       expect(result[0]).to be_the_type(types.host_class('apache'))
       expect(result[1]).to be_the_type(types.host_class('nginx'))
     end
 
     it 'removes leading :: in class name' do
-      expr = fqr('Class')['::evoe']
+      expr = fqr('Class').access_at('::evoe')
       expect(evaluate(expr)).to be_the_type(types.host_class('evoe'))
     end
 
     it 'raises error if the name is not a valid name' do
-      expr = fqr('Class')['fail-whale']
+      expr = fqr('Class').access_at('fail-whale')
       expect { evaluate(expr) }.to raise_error(/Illegal name/)
     end
 
     it 'downcases capitalized class names' do
-      expr = fqr('Class')['My::Class']
+      expr = fqr('Class').access_at('My::Class')
 
       expect(evaluate(expr)).to be_the_type(types.host_class('my::class'))
     end
 
     it 'gives an error if no keys are given as argument' do
-      expr = fqr('Class')[]
+      expr = fqr('Class').access_at
       expect {evaluate(expr)}.to raise_error(/Evaluation Error: Class\[\] accepts 1 or more arguments. Got 0/)
     end
 
     it 'produces an empty array if the keys reduce to empty array' do
-      expr = fqr('Class')[literal([[],[]])]
+      expr = fqr('Class').access_at(literal([[],[]]))
       expect(evaluate(expr)).to be_eql([])
     end
 
     # Resource
     it 'produces a specific resource type from Resource[type]' do
-      expr = fqr('Resource')[fqr('File')]
+      expr = fqr('Resource').access_at(fqr('File'))
       expect(evaluate(expr)).to be_the_type(types.resource('File'))
-      expr = fqr('Resource')[literal('File')]
+      expr = fqr('Resource').access_at(literal('File'))
       expect(evaluate(expr)).to be_the_type(types.resource('File'))
     end
 
     it 'does not allow the type to be specified in an array' do
       # arguments are flattened
-      expr = fqr('Resource')[[fqr('File')]]
+      expr = fqr('Resource').access_at([fqr('File')])
       expect{evaluate(expr)}.to raise_error(Puppet::ParseError, /must be a resource type or a String/)
     end
 
     it 'produces a specific resource reference type from File[title]' do
-      expr = fqr('File')[literal('/tmp/x')]
+      expr = fqr('File').access_at(literal('/tmp/x'))
       expect(evaluate(expr)).to be_the_type(types.resource('File', '/tmp/x'))
     end
 
     it 'produces a collection of specific resource references when multiple titles are used' do
       # Using a resource type
-      expr = fqr('File')[literal('x'),literal('y')]
+      expr = fqr('File').access_at(literal('x'),literal('y'))
       result = evaluate(expr)
       expect(result[0]).to be_the_type(types.resource('File', 'x'))
       expect(result[1]).to be_the_type(types.resource('File', 'y'))
 
       # Using generic resource
-      expr = fqr('Resource')[fqr('File'), literal('x'),literal('y')]
+      expr = fqr('Resource').access_at(fqr('File'), literal('x'),literal('y'))
       result = evaluate(expr)
       expect(result[0]).to be_the_type(types.resource('File', 'x'))
       expect(result[1]).to be_the_type(types.resource('File', 'y'))
@@ -447,32 +447,32 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
 
     it 'produces undef for Resource if arg is undef' do
       # arguments are flattened
-      expr = fqr('File')[nil]
+      expr = fqr('File').access_at(nil)
       expect(evaluate(expr)).to be_nil
     end
 
     it 'gives an error if no keys are given as argument to Resource' do
-      expr = fqr('Resource')[]
+      expr = fqr('Resource').access_at
       expect {evaluate(expr)}.to raise_error(/Evaluation Error: Resource\[\] accepts 1 or more arguments. Got 0/)
     end
 
     it 'produces an empty array if the type is given, and keys reduce to empty array for Resource' do
-      expr = fqr('Resource')[fqr('File'),literal([[],[]])]
+      expr = fqr('Resource').access_at(fqr('File'),literal([[],[]]))
       expect(evaluate(expr)).to be_eql([])
     end
 
     it 'gives an error i no keys are given as argument to a specific Resource type' do
-      expr = fqr('File')[]
+      expr = fqr('File').access_at
       expect {evaluate(expr)}.to raise_error(/Evaluation Error: File\[\] accepts 1 or more arguments. Got 0/)
     end
 
     it 'produces an empty array if the keys reduce to empty array for a specific Resource tyoe' do
-      expr = fqr('File')[literal([[],[]])]
+      expr = fqr('File').access_at(literal([[],[]]))
       expect(evaluate(expr)).to be_eql([])
     end
 
     it 'gives an error if resource is not found' do
-      expr = fqr('File')[fqn('x')][fqn('y')]
+      expr = fqr('File').access_at(fqn('x')).access_at(fqn('y'))
       expect {evaluate(expr)}.to raise_error(/Resource not found: File\['x'\]/)
     end
 
@@ -484,19 +484,19 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
     end
 
     it 'produces a NotUndef instance with contained type' do
-      type_expr = fqr('NotUndef')[fqr('Integer')]
+      type_expr = fqr('NotUndef').access_at(fqr('Integer'))
       tf = Puppet::Pops::Types::TypeFactory
       expect(evaluate(type_expr)).to eql(tf.not_undef(tf.integer))
     end
 
     it 'produces a NotUndef instance with String type when given a literal String' do
-      type_expr = fqr('NotUndef')[literal('hey')]
+      type_expr = fqr('NotUndef').access_at(literal('hey'))
       tf = Puppet::Pops::Types::TypeFactory
       expect(evaluate(type_expr)).to be_the_type(tf.not_undef(tf.string('hey')))
     end
 
     it 'Produces Optional instance with String type when using a String argument' do
-      type_expr = fqr('Optional')[literal('hey')]
+      type_expr = fqr('Optional').access_at(literal('hey'))
       tf = Puppet::Pops::Types::TypeFactory
       expect(evaluate(type_expr)).to be_the_type(tf.optional(tf.string('hey')))
     end
@@ -504,37 +504,37 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
     # Type Type
     #
     it 'creates a Type instance when applied to a Type' do
-      type_expr = fqr('Type')[fqr('Integer')]
+      type_expr = fqr('Type').access_at(fqr('Integer'))
       tf = Puppet::Pops::Types::TypeFactory
       expect(evaluate(type_expr)).to eql(tf.type_type(tf.integer))
 
       # arguments are flattened
-      type_expr = fqr('Type')[[fqr('Integer')]]
+      type_expr = fqr('Type').access_at([fqr('Integer')])
       expect(evaluate(type_expr)).to eql(tf.type_type(tf.integer))
     end
 
     # Ruby Type
     #
     it 'creates a Ruby Type instance when applied to a Ruby Type' do
-      type_expr = fqr('Runtime')['ruby','String']
+      type_expr = fqr('Runtime').access_at('ruby','String')
       tf = Puppet::Pops::Types::TypeFactory
       expect(evaluate(type_expr)).to eql(tf.ruby_type('String'))
 
       # arguments are flattened
-      type_expr = fqr('Runtime')[['ruby', 'String']]
+      type_expr = fqr('Runtime').access_at(['ruby', 'String'])
       expect(evaluate(type_expr)).to eql(tf.ruby_type('String'))
     end
 
     # Callable Type
     #
     it 'produces Callable instance without return type' do
-      type_expr = fqr('Callable')[fqr('String')]
+      type_expr = fqr('Callable').access_at(fqr('String'))
       tf = Puppet::Pops::Types::TypeFactory
       expect(evaluate(type_expr)).to eql(tf.callable(String))
     end
 
     it 'produces Callable instance with parameters and return type' do
-      type_expr = fqr('Callable')[[fqr('String')], fqr('Integer')]
+      type_expr = fqr('Callable').access_at([fqr('String')], fqr('Integer'))
       tf = Puppet::Pops::Types::TypeFactory
       expect(evaluate(type_expr)).to eql(tf.callable([String], Integer))
     end