diff --git a/acceptance/tests/apply/hashes/should_not_reassign.rb b/acceptance/tests/apply/hashes/should_not_reassign.rb
index 115e54b2b..885939ffe 100755
--- a/acceptance/tests/apply/hashes/should_not_reassign.rb
+++ b/acceptance/tests/apply/hashes/should_not_reassign.rb
@@ -1,19 +1,12 @@
 test_name "hash reassignment should fail"
 manifest = %q{
 $my_hash = {'one' => '1', 'two' => '2' }
 $my_hash['one']='1.5'
 }
 
 agents.each do |host|
-  parser = on(host, puppet('agent --configprint parser')).stdout.chomp
   apply_manifest_on(host, manifest, :acceptable_exit_codes => [1]) do
-    expected_error_message =
-    case parser
-    when 'future'
-      "Illegal attempt to assign via [index/key]. Not an assignable reference"
-    else
-      "Assigning to the hash 'my_hash' with an existing key 'one'"
-    end
+    expected_error_message = "Illegal attempt to assign via [index/key]. Not an assignable reference"
     fail_test("didn't find the failure") unless stderr.include?(expected_error_message)
   end
 end
diff --git a/acceptance/tests/environment/dynamic.rb b/acceptance/tests/environment/dynamic.rb
index b9eaae5c4..9d5a1d5f8 100644
--- a/acceptance/tests/environment/dynamic.rb
+++ b/acceptance/tests/environment/dynamic.rb
@@ -1,130 +1,127 @@
 test_name "dynamic environments"
 require 'puppet/acceptance/environment_utils'
 extend Puppet::Acceptance::EnvironmentUtils
 require 'puppet/acceptance/classifier_utils'
 extend Puppet::Acceptance::ClassifierUtils
 
 classify_nodes_as_agent_specified_if_classifer_present
 
 step "setup environments"
 
 stub_forge_on(master)
 
 testdir = create_tmpdir_for_user master, "confdir"
 puppet_conf_backup_dir = create_tmpdir_for_user(master, "puppet-conf-backup-dir")
 
 apply_manifest_on(master, environment_manifest(testdir), :catch_failures => true)
 
 results = {}
 review = {}
 
 ####################
 step "[ Run Tests ]"
 
 existing_dynamic_scenario = "Test a specific, existing dynamic environment configuration"
 step existing_dynamic_scenario
 master_opts = {
   'main' => {
     'environmentpath' => '',
     'manifest' => '$confdir/dynamic/$environment/manifests',
     'modulepath' => '$confdir/dynamic/$environment/modules',
     'config_version' => '$confdir/static-version.sh',
   }
 }
 if master.is_pe?
   master_opts['main']['modulepath'] << ":#{master['sitemoduledir']}"
 end
 
 results[existing_dynamic_scenario] = use_an_environment("testing", "dynamic testing", master_opts, testdir, puppet_conf_backup_dir)
 
 default_environment_scenario = "Test behavior of default environment"
 step default_environment_scenario
 results[default_environment_scenario] = use_an_environment(nil, "default environment", master_opts, testdir, puppet_conf_backup_dir)
 
 non_existent_environment_scenario = "Test for an environment that does not exist"
 step non_existent_environment_scenario
 results[non_existent_environment_scenario] = use_an_environment("doesnotexist", "non existent environment", master_opts, testdir, puppet_conf_backup_dir)
 
 ########################################
 step "[ Report on Environment Results ]"
 
 confdir = master.puppet['confdir']
 
 step "Reviewing: #{existing_dynamic_scenario}"
 review[existing_dynamic_scenario] = review_results(results[existing_dynamic_scenario],
   :puppet_config => {
     :exit_code => 0,
     :matches => [%r{manifest.*#{confdir}/dynamic/testing/manifests$},
                  %r{modulepath.*#{confdir}/dynamic/testing/modules(?::#{master['sitemoduledir']})?$},
                  %r{config_version.*#{confdir}/static-version.sh$}]
   },
   :puppet_module_install => {
     :exit_code => 0,
     :matches => [%r{Preparing to install into #{confdir}/dynamic/testing/modules},
                  %r{pmtacceptance-nginx}],
   },
   :puppet_module_uninstall => {
     :exit_code => 0,
     :matches => [%r{Removed.*pmtacceptance-nginx.*from #{confdir}/dynamic/testing/modules}],
   },
   :puppet_apply => {
     :exit_code => 0,
     :matches => [%r{include dynamic testing environment testing_mod}],
   },
   :puppet_agent => {
     :exit_code => 2,
     :matches => [%r{Applying configuration version 'static'},
                  %r{in dynamic testing environment site.pp},
                  %r{include dynamic testing environment testing_mod}],
   }
 )
 
 step "Reviewing: #{default_environment_scenario}"
 default_expectations = lambda do |env|
   {
     :puppet_config => {
       :exit_code => 0,
       :matches => [%r{manifest.*#{confdir}/dynamic/#{env}/manifests$},
                    %r{modulepath.*#{confdir}/dynamic/#{env}/modules(?::#{master['sitemoduledir']})?$},
                    %r{^config_version.*#{confdir}/static-version.sh$}]
     },
     :puppet_module_install => {
       :exit_code => 0,
       :matches => [%r{Preparing to install into #{confdir}/dynamic/#{env}/modules},
                    %r{pmtacceptance-nginx}],
     },
     :puppet_module_uninstall => {
       :exit_code => 0,
       :matches => [%r{Removed.*pmtacceptance-nginx.*from #{confdir}/dynamic/#{env}/modules}],
     },
     :puppet_apply => {
       :exit_code => 1,
-      :matches => [ENV['PARSER'] == 'future' ?
-                   %r{Error:.*Could not find class ::testing_mod} :
-                   %r{Error:.*Could not find class testing_mod}
-                  ],
+      :matches => [%r{Error:.*Could not find class ::testing_mod}],
     },
     :puppet_agent => {
       :exit_code => 0,
       :matches => [%r{Applying configuration version 'static'}],
       :does_not_match => [%r{in default environment site.pp},
                           %r{include default environment testing_mod},
                           %r{Notice: include}],
     },
   }
 end
 review[default_environment_scenario] = review_results(
   results[default_environment_scenario],
   default_expectations.call('production')
 )
 
 step "Reviewing: #{non_existent_environment_scenario}"
 review[non_existent_environment_scenario] = review_results(
   results[non_existent_environment_scenario],
   default_expectations.call('doesnotexist')
 )
 
 #########################
 step "[ Assert Success ]"
 
 assert_review(review)
diff --git a/acceptance/tests/loader/func4x_loadable_from_modules.rb b/acceptance/tests/loader/func4x_loadable_from_modules.rb
index 60414d4b7..c59f92764 100644
--- a/acceptance/tests/loader/func4x_loadable_from_modules.rb
+++ b/acceptance/tests/loader/func4x_loadable_from_modules.rb
@@ -1,83 +1,83 @@
 test_name "Exercise a module with 4x function and 4x system function"
 
 # Purpose:
 # Test that a packed puppet can call a 4x system function, and that a 4x function in
 # a module can be called.
 #
 # Method:
 # * Manually construct a very simple module with a manifest that creates a file.
 # * The file has content that depends on logic that calls both a system function (reduce), and
 #   a function supplied in the module (helloworld::mul10).
 # * The module is manually constructed to allow the test to also run on Windows where the module tool
 #   is not supported.
 # * The module is included by calling 'include' from 'puppet apply'.
 # * Puppet apply is executed to generate the file with the content.
 # * The generated contents is asserted.
 
 # TODO: The test can be improved by adding yet another module that calls the function in helloworld.
 # TODO: The test can be improved to also test loading of a non namespaced function
 
 require 'puppet/acceptance/temp_file_utils'
 extend Puppet::Acceptance::TempFileUtils
 initialize_temp_dirs
 
 agents.each do |agent|
   # The modulepath to use in environment 'dev'
   envs_path = get_test_file_path(agent, 'environments')
   dev_modulepath = get_test_file_path(agent, 'environments/dev/modules')
   target_path = get_test_file_path(agent, 'output')
   mkdirs agent, target_path
 
   # make sure that we use the modulepath from the dev environment
   puppetconf = get_test_file_path(agent, 'puppet.conf')
   user = agent.puppet['user']
   group = agent.puppet['group']
   # Setting user/group ensures that when puppet apply's Configurer use()'s the
   # settings, that it doesn't default to owning them as root, which can have an
   # impact on following tests.
   on agent, puppet("config", "set", "user", user, "--section", "main", "--config", puppetconf)
   on agent, puppet("config", "set", "group", group, "--section", "main", "--config", puppetconf)
   on agent, puppet("config", "set", "environment", "dev", "--section", "user", "--config", puppetconf)
   on agent, puppet("config", "set", "environmentpath", envs_path, "--section", "main", "--config", puppetconf)
 
   # Where the functions in the written modules should go
   helloworld_functions = 'helloworld/lib/puppet/functions/helloworld'
   # Clean out the module that will be written to ensure no interference from a previous run
   on agent, "rm -rf #{File.join(dev_modulepath, 'helloworld')}"
   mkdirs agent, File.join(dev_modulepath, helloworld_functions)
 
   # Write a module
   # Write the function helloworld::mul10, that multiplies its argument by 10
   create_remote_file(agent, File.join(dev_modulepath, helloworld_functions, "mul10.rb"), <<'SOURCE')
 Puppet::Functions.create_function(:'helloworld::mul10') do
   def mul10(x)
     x * 10
   end
 end
 SOURCE
 
   # Write a manifest that calls a 4x function (reduce), and calls a function defined in the module
   # (helloworld::mul10).
   #
   mkdirs agent, File.join(dev_modulepath, "helloworld", "manifests")
   create_remote_file(agent, File.join(dev_modulepath, "helloworld", "manifests", "init.pp"), <<SOURCE)
 class helloworld {
   file { "#{target_path}/result.txt":
     ensure => 'file',
     mode => '0666',
     content => [1,2,3].reduce("Generated") |$memo, $n| {
       "${memo}, ${n} => ${helloworld::mul10($n)}"
     }
   }
 }
 SOURCE
 
   # Run apply to generate the file with the output
-  on agent, puppet('apply', '--parser', 'future', '-e', "'include helloworld'", '--config', puppetconf)
+  on agent, puppet('apply', '-e', "'include helloworld'", '--config', puppetconf)
 
   # Assert that the file was written with the generated content
   on(agent, "cat #{File.join(target_path, 'result.txt')}") do
     assert_match(/^Generated, 1 => 10, 2 => 20, 3 => 30$/, stdout, "Generated the wrong content")
   end
 
 end
diff --git a/lib/puppet/functions/each.rb b/lib/puppet/functions/each.rb
index 1b9ac937c..5a5c39dac 100644
--- a/lib/puppet/functions/each.rb
+++ b/lib/puppet/functions/each.rb
@@ -1,111 +1,109 @@
 #  Applies a parameterized block to each element in a sequence of selected entries from the first
 #  argument and returns the first argument.
 #
 # This function takes two mandatory arguments: the first should be an Array or a Hash or something that is
 # of enumerable type (integer, Integer range, or String), and the second
 # a parameterized block as produced by the puppet syntax:
 #
 #       $a.each |$x| { ... }
 #       each($a) |$x| { ... }
 #
 # When the first argument is an Array (or of enumerable type other than Hash), the parameterized block
 # should define one or two block parameters.
 # For each application of the block, the next element from the array is selected, and it is passed to
 # the block if the block has one parameter. If the block has two parameters, the first is the elements
 # index, and the second the value. The index starts from 0.
 #
 #       $a.each |$index, $value| { ... }
 #       each($a) |$index, $value| { ... }
 #
 # When the first argument is a Hash, the parameterized block should define one or two parameters.
 # When one parameter is defined, the iteration is performed with each entry as an array of `[key, value]`,
 # and when two parameters are defined the iteration is performed with key and value.
 #
 #       $a.each |$entry|       { ..."key ${$entry[0]}, value ${$entry[1]}" }
 #       $a.each |$key, $value| { ..."key ${key}, value ${value}" }
 #
 # @example using each
 #
 #       [1,2,3].each |$val| { ... }                       # 1, 2, 3
 #       [5,6,7].each |$index, $val| { ... }               # (0, 5), (1, 6), (2, 7)
 #       {a=>1, b=>2, c=>3}].each |$val| { ... }           # ['a', 1], ['b', 2], ['c', 3]
 #       {a=>1, b=>2, c=>3}.each |$key, $val| { ... }      # ('a', 1), ('b', 2), ('c', 3)
 #       Integer[ 10, 20 ].each |$index, $value| { ... }   # (0, 10), (1, 11) ...
 #       "hello".each |$char| { ... }                      # 'h', 'e', 'l', 'l', 'o'
 #       3.each |$number| { ... }                          # 0, 1, 2
 #
-# @since 3.2 for Array and Hash
-# @since 3.5 for other enumerables
-# @note requires `parser = future`
+# @since 4.0.0
 #
 Puppet::Functions.create_function(:each) do
   dispatch :foreach_Hash_2 do
     param 'Hash[Any, Any]', :hash
     required_block_param 'Callable[2,2]', :block
   end
 
   dispatch :foreach_Hash_1 do
     param 'Hash[Any, Any]', :hash
     required_block_param 'Callable[1,1]', :block
   end
 
   dispatch :foreach_Enumerable_2 do
     param 'Any', :enumerable
     required_block_param 'Callable[2,2]', :block
   end
 
   dispatch :foreach_Enumerable_1 do
     param 'Any', :enumerable
     required_block_param 'Callable[1,1]', :block
   end
 
   def foreach_Hash_1(hash, pblock)
     enumerator = hash.each_pair
     hash.size.times do
       pblock.call(nil, enumerator.next)
     end
     # produces the receiver
     hash
   end
 
   def foreach_Hash_2(hash, pblock)
     enumerator = hash.each_pair
     hash.size.times do
       pblock.call(nil, *enumerator.next)
     end
     # produces the receiver
     hash
   end
 
   def foreach_Enumerable_1(enumerable, pblock)
     enum = asserted_enumerable(enumerable)
       begin
         loop { pblock.call(nil, enum.next) }
       rescue StopIteration
       end
     # produces the receiver
     enumerable
   end
 
   def foreach_Enumerable_2(enumerable, pblock)
     enum = asserted_enumerable(enumerable)
     index = 0
     begin
       loop do
         pblock.call(nil, index, enum.next)
         index += 1
       end
     rescue StopIteration
     end
     # produces the receiver
     enumerable
   end
 
   def asserted_enumerable(obj)
     unless enum = Puppet::Pops::Types::Enumeration.enumerator(obj)
       raise ArgumentError, ("#{self.class.name}(): wrong argument type (#{obj.class}; must be something enumerable.")
     end
     enum
   end
 
 end
diff --git a/lib/puppet/functions/epp.rb b/lib/puppet/functions/epp.rb
index baa0c1bed..35ff0286c 100644
--- a/lib/puppet/functions/epp.rb
+++ b/lib/puppet/functions/epp.rb
@@ -1,54 +1,54 @@
 # Evaluates an Embedded Puppet Template (EPP) file and returns the rendered text result as a String.
 #
 # The first argument to this function should be a `<MODULE NAME>/<TEMPLATE FILE>`
 # reference, which will load `<TEMPLATE FILE>` from a module's `templates`
 # directory. (For example, the reference `apache/vhost.conf.epp` will load the
 # file `<MODULES DIRECTORY>/apache/templates/vhost.conf.epp`.)
 #
 # The second argument is optional; if present, it should be a hash containing parameters for the
 # template. (See below.)
 #
 # EPP supports the following tags:
 #
 # * `<%= puppet expression %>` - This tag renders the value of the expression it contains.
 # * `<% puppet expression(s) %>` - This tag will execute the expression(s) it contains, but renders nothing.
 # * `<%# comment %>` - The tag and its content renders nothing.
 # * `<%%` or `%%>` - Renders a literal `<%` or `%>` respectively.
 # * `<%-` - Same as `<%` but suppresses any leading whitespace.
 # * `-%>` - Same as `%>` but suppresses any trailing whitespace on the same line (including line break).
 # * `<%- |parameters| -%>` - When placed as the first tag declares the template's parameters.
 #
 # File based EPP supports the following visibilities of variables in scope:
 #
 # * Global scope (i.e. top + node scopes) - global scope is always visible
 # * Global + all given arguments - if the EPP template does not declare parameters, and arguments are given
 # * Global + declared parameters - if the EPP declares parameters, given argument names must match
 #
 # EPP supports parameters by placing an optional parameter list as the very first element in the EPP. As an example,
 # `<%- |$x, $y, $z = 'unicorn'| -%>` when placed first in the EPP text declares that the parameters `x` and `y` must be
 # given as template arguments when calling `inline_epp`, and that `z` if not given as a template argument
 # defaults to `'unicorn'`. Template parameters are available as variables, e.g.arguments `$x`, `$y` and `$z` in the example.
 # Note that `<%-` must be used or any leading whitespace will be interpreted as text
 #
 # Arguments are passed to the template by calling `epp` with a Hash as the last argument, where parameters
 # are bound to values, e.g. `epp('...', {'x'=>10, 'y'=>20})`. Excess arguments may be given
 # (i.e. undeclared parameters) only if the EPP templates does not declare any parameters at all.
 # Template parameters shadow variables in outer scopes. File based epp does never have access to variables in the
 # scope where the `epp` function is called from.
 #
 # @see function inline_epp for examples of EPP
-# @since 3.5
-# @note Requires Future Parser
+# @since 4.0.0
+#
 Puppet::Functions.create_function(:epp, Puppet::Functions::InternalFunction) do
 
   dispatch :epp do
     scope_param()
     param 'String', 'path'
     param 'Hash[Pattern[/^\w+$/], Any]', 'parameters'
     arg_count(1, 2)
   end
 
   def epp(scope, path, parameters = nil)
     Puppet::Pops::Evaluator::EppEvaluator.epp(scope, path, scope.compiler.environment, parameters)
   end
 end
\ No newline at end of file
diff --git a/lib/puppet/functions/filter.rb b/lib/puppet/functions/filter.rb
index 0654d9c9c..9573af9ad 100644
--- a/lib/puppet/functions/filter.rb
+++ b/lib/puppet/functions/filter.rb
@@ -1,113 +1,111 @@
 # Applies a parameterized block to each element in a sequence of entries from the first
 # argument and returns an array or hash (same type as left operand for array/hash, and array for
 # other enumerable types) with the entries for which the block evaluates to `true`.
 #
 # This function takes two mandatory arguments: the first should be an Array, a Hash, or an
 # Enumerable object (integer, Integer range, or String),
 # and the second a parameterized block as produced by the puppet syntax:
 #
 #       $a.filter |$x| { ... }
 #       filter($a) |$x| { ... }
 #
 # When the first argument is something other than a Hash, the block is called with each entry in turn.
 # When the first argument is a Hash the entry is an array with `[key, value]`.
 #
 # @example Using filter with one parameter
 #
 #       # selects all that end with berry
 #       $a = ["raspberry", "blueberry", "orange"]
 #       $a.filter |$x| { $x =~ /berry$/ }          # rasberry, blueberry
 #
 # If the block defines two parameters, they will be set to `index, value` (with index starting at 0) for all
 # enumerables except Hash, and to `key, value` for a Hash.
 #
 # @example Using filter with two parameters
 #
 #      # selects all that end with 'berry' at an even numbered index
 #      $a = ["raspberry", "blueberry", "orange"]
 #      $a.filter |$index, $x| { $index % 2 == 0 and $x =~ /berry$/ } # raspberry
 #
 #      # selects all that end with 'berry' and value >= 1
 #      $a = {"raspberry"=>0, "blueberry"=>1, "orange"=>1}
 #      $a.filter |$key, $x| { $x =~ /berry$/ and $x >= 1 } # blueberry
 #
-# @since 3.4 for Array and Hash
-# @since 3.5 for other enumerables
-# @note requires `parser = future`
+# @since 4.0.0
 #
 Puppet::Functions.create_function(:filter) do
   dispatch :filter_Hash_2 do
     param 'Hash[Any, Any]', :hash
     required_block_param 'Callable[2,2]', :block
   end
 
   dispatch :filter_Hash_1 do
     param 'Hash[Any, Any]', :hash
     required_block_param 'Callable[1,1]', :block
   end
 
   dispatch :filter_Enumerable_2 do
     param 'Any', :enumerable
     required_block_param 'Callable[2,2]', :block
   end
 
   dispatch :filter_Enumerable_1 do
     param 'Any', :enumerable
     required_block_param 'Callable[1,1]', :block
   end
 
   def filter_Hash_1(hash, pblock)
     result = hash.select {|x, y| pblock.call(self, [x, y]) }
     # Ruby 1.8.7 returns Array
     result = Hash[result] unless result.is_a? Hash
     result
   end
 
   def filter_Hash_2(hash, pblock)
     result = hash.select {|x, y| pblock.call(self, x, y) }
     # Ruby 1.8.7 returns Array
     result = Hash[result] unless result.is_a? Hash
     result
   end
 
   def filter_Enumerable_1(enumerable, pblock)
     result = []
     index = 0
     enum = asserted_enumerable(enumerable)
     begin
       loop do
         it = enum.next
         if pblock.call(nil, it) == true
           result << it
         end
       end
     rescue StopIteration
     end
     result
   end
 
   def filter_Enumerable_2(enumerable, pblock)
     result = []
     index = 0
     enum = asserted_enumerable(enumerable)
     begin
       loop do
         it = enum.next
         if pblock.call(nil, index, it) == true
           result << it
         end
         index += 1
       end
     rescue StopIteration
     end
     result
   end
 
   def asserted_enumerable(obj)
     unless enum = Puppet::Pops::Types::Enumeration.enumerator(obj)
       raise ArgumentError, ("#{self.class.name}(): wrong argument type (#{obj.class}; must be something enumerable.")
     end
     enum
   end
 
 end
diff --git a/lib/puppet/functions/inline_epp.rb b/lib/puppet/functions/inline_epp.rb
index 31a966334..a0f063a0e 100644
--- a/lib/puppet/functions/inline_epp.rb
+++ b/lib/puppet/functions/inline_epp.rb
@@ -1,88 +1,87 @@
 # Evaluates an Embedded Puppet Template (EPP) string and returns the rendered text result as a String.
 #
 # EPP support the following tags:
 #
 # * `<%= puppet expression %>` - This tag renders the value of the expression it contains.
 # * `<% puppet expression(s) %>` - This tag will execute the expression(s) it contains, but renders nothing.
 # * `<%# comment %>` - The tag and its content renders nothing.
 # * `<%%` or `%%>` - Renders a literal `<%` or `%>` respectively.
 # * `<%-` - Same as `<%` but suppresses any leading whitespace.
 # * `-%>` - Same as `%>` but suppresses any trailing whitespace on the same line (including line break).
 # * `<%- |parameters| -%>` - When placed as the first tag declares the template's parameters.
 #
 # Inline EPP supports the following visibilities of variables in scope which depends on how EPP parameters
 # are used - see further below:
 #
 # * Global scope (i.e. top + node scopes) - global scope is always visible
 # * Global + Enclosing scope - if the EPP template does not declare parameters, and no arguments are given
 # * Global + all given arguments - if the EPP template does not declare parameters, and arguments are given
 # * Global + declared parameters - if the EPP declares parameters, given argument names must match
 #
 # EPP supports parameters by placing an optional parameter list as the very first element in the EPP. As an example,
 # `<%- |$x, $y, $z='unicorn'| -%>` when placed first in the EPP text declares that the parameters `x` and `y` must be
 # given as template arguments when calling `inline_epp`, and that `z` if not given as a template argument
 # defaults to `'unicorn'`. Template parameters are available as variables, e.g.arguments `$x`, `$y` and `$z` in the example.
 # Note that `<%-` must be used or any leading whitespace will be interpreted as text
 #
 # Arguments are passed to the template by calling `inline_epp` with a Hash as the last argument, where parameters
 # are bound to values, e.g. `inline_epp('...', {'x'=>10, 'y'=>20})`. Excess arguments may be given
 # (i.e. undeclared parameters) only if the EPP templates does not declare any parameters at all.
 # Template parameters shadow variables in outer scopes.
 #
 # Note: An inline template is best stated using a single-quoted string, or a heredoc since a double-quoted string
 # is subject to expression interpolation before the string is parsed as an EPP template. Here are examples
 # (using heredoc to define the EPP text):
 #
 # @example Various Examples using `inline_epp`
 #
 #     # produces 'Hello local variable world!'
 #     $x ='local variable'
 #     inline_epptemplate(@(END:epp))
 #     <%- |$x| -%>
 #     Hello <%= $x %> world!
 #     END
 # 
 #     # produces 'Hello given argument world!'
 #     $x ='local variable world'
 #     inline_epptemplate(@(END:epp), { x =>'given argument'})
 #     <%- |$x| -%>
 #     Hello <%= $x %> world!
 #     END
 #
 #     # produces 'Hello given argument world!'
 #     $x ='local variable world'
 #     inline_epptemplate(@(END:epp), { x =>'given argument'})
 #     <%- |$x| -%>
 #     Hello <%= $x %>!
 #     END
 #
 #     # results in error, missing value for y
 #     $x ='local variable world'
 #     inline_epptemplate(@(END:epp), { x =>'given argument'})
 #     <%- |$x, $y| -%>
 #     Hello <%= $x %>!
 #     END
 #
 #     # Produces 'Hello given argument planet'
 #     $x ='local variable world'
 #     inline_epptemplate(@(END:epp), { x =>'given argument'})
 #     <%- |$x, $y=planet| -%>
 #     Hello <%= $x %> <%= $y %>!
 #     END
 #
-# @since 3.5
-# @note Requires Future Parser
+# @since 4.0.0
 #
 Puppet::Functions.create_function(:inline_epp, Puppet::Functions::InternalFunction) do
 
   dispatch :inline_epp do
     scope_param()
     param 'String', 'template'
     param 'Hash[Pattern[/^\w+$/], Any]', 'parameters'
     arg_count(1, 2)
   end
 
   def inline_epp(scope, template, parameters = nil)
     Puppet::Pops::Evaluator::EppEvaluator.inline_epp(scope, template, parameters)
   end
 end
diff --git a/lib/puppet/functions/map.rb b/lib/puppet/functions/map.rb
index 2141d1e81..355013e42 100644
--- a/lib/puppet/functions/map.rb
+++ b/lib/puppet/functions/map.rb
@@ -1,97 +1,95 @@
 # Applies a parameterized block to each element in a sequence of entries from the first
 # argument and returns an array with the result of each invocation of the parameterized block.
 #
 # This function takes two mandatory arguments: the first should be an Array, Hash, or of Enumerable type
 # (integer, Integer range, or String), and the second a parameterized block as produced by the puppet syntax:
 #
 #       $a.map |$x| { ... }
 #       map($a) |$x| { ... }
 #
 # When the first argument `$a` is an Array or of enumerable type, the block is called with each entry in turn.
 # When the first argument is a hash the entry is an array with `[key, value]`.
 #
 # @example Using map with two arguments
 #
 #      # Turns hash into array of values
 #      $a.map |$x|{ $x[1] }
 #
 #      # Turns hash into array of keys
 #      $a.map |$x| { $x[0] }
 #
 # When using a block with 2 parameters, the element's index (starting from 0) for an array, and the key for a hash
 # is given to the block's first parameter, and the value is given to the block's second parameter.args.
 #
 # @example Using map with two arguments
 #
 #      # Turns hash into array of values
 #      $a.map |$key,$val|{ $val }
 #
 #      # Turns hash into array of keys
 #      $a.map |$key,$val|{ $key }
 #
-# @since 3.4 for Array and Hash
-# @since 3.5 for other enumerables, and support for blocks with 2 parameters
-# @note requires `parser = future`
+# @since 4.0.0
 #
 Puppet::Functions.create_function(:map) do
   dispatch :map_Hash_2 do
     param 'Hash[Any, Any]', :hash
     required_block_param 'Callable[2,2]', :block
   end
 
   dispatch :map_Hash_1 do
     param 'Hash[Any, Any]', :hash
     required_block_param 'Callable[1,1]', :block
   end
 
   dispatch :map_Enumerable_2 do
     param 'Any', :enumerable
     required_block_param 'Callable[2,2]', :block
   end
 
   dispatch :map_Enumerable_1 do
     param 'Any', :enumerable
     required_block_param 'Callable[1,1]', :block
   end
 
   def map_Hash_1(hash, pblock)
     hash.map {|x, y| pblock.call(nil, [x, y]) }
   end
 
   def map_Hash_2(hash, pblock)
       hash.map {|x, y| pblock.call(nil, x, y) }
   end
 
   def map_Enumerable_1(enumerable, pblock)
     result = []
     index = 0
     enum = asserted_enumerable(enumerable)
     begin
       loop { result << pblock.call(nil, enum.next) }
     rescue StopIteration
     end
     result
   end
 
   def map_Enumerable_2(enumerable, pblock)
     result = []
     index = 0
     enum = asserted_enumerable(enumerable)
     begin
       loop do
         result << pblock.call(nil, index, enum.next)
         index = index +1
       end
     rescue StopIteration
     end
     result
   end
 
   def asserted_enumerable(obj)
     unless enum = Puppet::Pops::Types::Enumeration.enumerator(obj)
       raise ArgumentError, ("#{self.class.name}(): wrong argument type (#{obj.class}; must be something enumerable.")
     end
     enum
   end
 
 end
diff --git a/lib/puppet/functions/match.rb b/lib/puppet/functions/match.rb
index 8808a29b6..d13d87223 100644
--- a/lib/puppet/functions/match.rb
+++ b/lib/puppet/functions/match.rb
@@ -1,102 +1,102 @@
 # Returns the match result of matching a String or Array[String] with one of:
 #
 # * Regexp
 # * String - transformed to a Regexp
 # * Pattern type
 # * Regexp type
 #
 # Returns An Array with the entire match at index 0, and each subsequent submatch at index 1-n.
 # If there was no match, nil (ie. undef) is returned. If the value to match is an Array, a array
 # with mapped match results is returned.
 #
 # @example matching
 #   "abc123".match(/([a-z]+)[1-9]+/)  # => ["abc"]
 #   "abc123".match(/([a-z]+)([1-9]+)/)  # => ["abc", "123"]
 #
 # See the documentation for "The Puppet Type System" for more information about types.
-# @since 3.7.0
+# @since 4.0.0
 #
 Puppet::Functions.create_function(:match) do
   dispatch :match do
     param 'String', 'string'
     param 'Variant[Any, Type]', 'pattern'
   end
 
   dispatch :enumerable_match do
     param 'Array[String]', 'string'
     param 'Variant[Any, Type]', 'pattern'
   end
 
   def initialize(closure_scope, loader)
     super
 
     # Make this visitor shared among all instantiations of this function since it is faster.
     # This can be used because it is not possible to replace
     # a puppet runtime (where this function is) without a reboot. If you model a function in a module after
     # this class, use a regular instance variable instead to enable reloading of the module without reboot
     #
     @@match_visitor   ||= Puppet::Pops::Visitor.new(self, "match", 1, 1)
   end
 
   # Matches given string against given pattern and returns an Array with matches.
   # @param string [String] the string to match
   # @param pattern [String, Regexp, Puppet::Pops::Types::PPatternType, Puppet::Pops::PRegexpType, Array] the pattern
   # @return [Array<String>] matches where first match is the entire match, and index 1-n are captures from left to right
   #
   def match(string, pattern)
     @@match_visitor.visit_this_1(self, pattern, string)
   end
 
   # Matches given Array[String] against given pattern and returns an Array with mapped match results.
   #
   # @param array [Array<String>] the array of strings to match
   # @param pattern [String, Regexp, Puppet::Pops::Types::PPatternType, Puppet::Pops::PRegexpType, Array] the pattern
   # @return [Array<Array<String, nil>>] Array with matches (see {#match}), non matching entries produce a nil entry
   #
   def enumerable_match(array, pattern)
     array.map {|s| match(s, pattern) }
   end
 
   protected
 
   def match_Object(obj, s)
     msg = "match() expects pattern of T, where T is String, Regexp, Regexp[r], Pattern[p], or Array[T]. Got #{obj.class}"
     raise ArgumentError, msg
   end
 
   def match_String(pattern_string, s)
     do_match(s, Regexp.new(pattern_string))
   end
 
   def match_Regexp(regexp, s)
     do_match(s, regexp)
   end
 
   def match_PRegexpType(regexp_t, s)
     raise ArgumentError, "Given Regexp Type has no regular expression" unless regexp_t.pattern
     do_match(s, regexp_t.regexp)
   end
 
   def match_PPatternType(pattern_t, s)
     # Since we want the actual match result (not just a boolean), an iteration over
     # Pattern's regular expressions is needed. (They are of PRegexpType)
     result = nil
     pattern_t.patterns.find {|pattern| result = match(s, pattern) }
     result
   end
 
   # Returns the first matching entry
   def match_Array(array, s)
     result = nil
     array.flatten.find {|entry| result = match(s, entry) }
     result
   end
 
   private
 
   def do_match(s, regexp)
     if result = regexp.match(s)
       result.to_a
     end
   end
 end
diff --git a/lib/puppet/functions/reduce.rb b/lib/puppet/functions/reduce.rb
index 5b54e41c5..4add16422 100644
--- a/lib/puppet/functions/reduce.rb
+++ b/lib/puppet/functions/reduce.rb
@@ -1,94 +1,92 @@
 # Applies a parameterized block to each element in a sequence of entries from the first
 # argument (_the enumerable_) and returns the last result of the invocation of the parameterized block.
 #
 # This function takes two mandatory arguments: the first should be an Array, Hash, or something of
 # enumerable type, and the last a parameterized block as produced by the puppet syntax:
 #
 #       $a.reduce |$memo, $x| { ... }
 #       reduce($a) |$memo, $x| { ... }
 #
 # When the first argument is an Array or someting of an enumerable type, the block is called with each entry in turn.
 # When the first argument is a hash each entry is converted to an array with `[key, value]` before being
 # fed to the block. An optional 'start memo' value may be supplied as an argument between the array/hash
 # and mandatory block.
 #
 #       $a.reduce(start) |$memo, $x| { ... }
 #       reduce($a, start) |$memo, $x| { ... }
 #
 # If no 'start memo' is given, the first invocation of the parameterized block will be given the first and second
 # elements of the enumeration, and if the enumerable has fewer than 2 elements, the first
 # element is produced as the result of the reduction without invocation of the block.
 #
 # On each subsequent invocation, the produced value of the invoked parameterized block is given as the memo in the
 # next invocation.
 #
 # @example Using reduce
 #
 #       # Reduce an array
 #       $a = [1,2,3]
 #       $a.reduce |$memo, $entry| { $memo + $entry }
 #       #=> 6
 #
 #       # Reduce hash values
 #       $a = {a => 1, b => 2, c => 3}
 #       $a.reduce |$memo, $entry| { [sum, $memo[1]+$entry[1]] }
 #       #=> [sum, 6]
 #
 #       # reverse a string
 #       "abc".reduce |$memo, $char| { "$char$memo" }
 #       #=>"cbe"
 #
 # It is possible to provide a starting 'memo' as an argument.
 #
 # @example Using reduce with given start 'memo'
 #
 #       # Reduce an array
 #       $a = [1,2,3]
 #       $a.reduce(4) |$memo, $entry| { $memo + $entry }
 #       #=> 10
 #
 #       # Reduce hash values
 #       $a = {a => 1, b => 2, c => 3}
 #       $a.reduce([na, 4]) |$memo, $entry| { [sum, $memo[1]+$entry[1]] }
 #       #=> [sum, 10]
 #
 # @example Using reduce with an Integer range
 #
 #       Integer[1,4].reduce |$memo, $x| { $memo + $x }
 #       #=> 10
 #
-# @since 3.2 for Array and Hash
-# @since 3.5 for additional enumerable types
-# @note requires `parser = future`.
+# @since 4.0.0
 #
 Puppet::Functions.create_function(:reduce) do
 
   dispatch :reduce_without_memo do
     param 'Any', :enumerable
     required_block_param 'Callable[2,2]', :block
   end
 
   dispatch :reduce_with_memo do
     param 'Any', :enumerable
     param 'Any', :memo
     required_block_param 'Callable[2,2]', :block
   end
 
   def reduce_without_memo(enumerable, pblock)
     enum = asserted_enumerable(enumerable)
     enum.reduce {|memo, x| pblock.call(nil, memo, x) }
   end
 
   def reduce_with_memo(enumerable, given_memo, pblock)
     enum = asserted_enumerable(enumerable)
     enum.reduce(given_memo) {|memo, x| pblock.call(nil, memo, x) }
   end
 
   def asserted_enumerable(obj)
     unless enum = Puppet::Pops::Types::Enumeration.enumerator(obj)
       raise ArgumentError, ("#{self.class.name}(): wrong argument type (#{obj.class}; must be something enumerable.")
     end
     enum
   end
 
 end
diff --git a/lib/puppet/functions/scanf.rb b/lib/puppet/functions/scanf.rb
index f107c68a8..d47eb30e1 100644
--- a/lib/puppet/functions/scanf.rb
+++ b/lib/puppet/functions/scanf.rb
@@ -1,46 +1,47 @@
 # Scans a string and returns an array of one or more converted values as directed by a given format string.args
 # See the documenation of Ruby's String::scanf method for details about the supported formats (which
 # are similar but not identical to the formats used in Puppet's `sprintf` function.
 #
 # This function takes two mandatory arguments: the first is the String to convert, and the second
 # the format String. A parameterized block may optionally be given, which is called with the result
 # that is produced by scanf if no block is present, the result of the block is then returned by
 # the function.
 #
 # The result of the scan is an Array, with each sucessfully scanned and transformed value.args The scanning
 # stops if a scan is unsuccesful and the scanned result up to that point is returned. If there was no
 # succesful scan at all, the result is an empty Array. The optional code block is typically used to
 # assert that the scan was succesful, and either produce the same input, or perform unwrapping of
 # the result
 #
 # @example scanning an integer in string form (result is an array with
 #   integer, or empty if  unsuccessful)
 #    "42".scanf("%i")
 #
 # @example scanning and processing resulting array to assert result and unwrap
 #
 #     "42".scanf("%i") |$x| {
 #       unless $x[0] =~ Integer {
 #         fail "Expected a well formed integer value, got '$x[0]'"
 #       }
 #       $x[0]
 #     }
 #
-# @since 3.7.4
+# @since 4.0.0
+#
 Puppet::Functions.create_function(:scanf) do
   require 'scanf'
 
   dispatch :scanf do
     param 'String', 'data'
     param 'String', 'format'
     optional_block_param
   end
 
   def scanf(data, format, block=nil)
     result = data.scanf(format)
     if !block.nil?
       result = block.call({}, result)
     end
     result
   end
 end
diff --git a/lib/puppet/functions/slice.rb b/lib/puppet/functions/slice.rb
index ef3a2932a..c4d3aaaa2 100644
--- a/lib/puppet/functions/slice.rb
+++ b/lib/puppet/functions/slice.rb
@@ -1,126 +1,124 @@
 # Applies a parameterized block to each _slice_ of elements in a sequence of selected entries from the first
 # argument and returns the first argument, or if no block is given returns a new array with a concatenation of
 # the slices.
 #
 # This function takes two mandatory arguments: the first, `$a`, should be an Array, Hash, or something of
 # enumerable type (integer, Integer range, or String), and the second, `$n`, the number of elements to include
 # in each slice. The optional third argument should be a a parameterized block as produced by the puppet syntax:
 #
 #     $a.slice($n) |$x| { ... }
 #     slice($a) |$x| { ... }
 #
 # The parameterized block should have either one parameter (receiving an array with the slice), or the same number
 # of parameters as specified by the slice size (each parameter receiving its part of the slice).
 # In case there are fewer remaining elements than the slice size for the last slice it will contain the remaining
 # elements. When the block has multiple parameters, excess parameters are set to undef for an array or
 # enumerable type, and to empty arrays for a Hash.
 #
 #     $a.slice(2) |$first, $second| { ... }
 #
 # When the first argument is a Hash, each `key,value` entry is counted as one, e.g, a slice size of 2 will produce
 # an array of two arrays with key, and value.
 #
 # @example Using slice with Hash
 #
 #     $a.slice(2) |$entry|          { notice "first ${$entry[0]}, second ${$entry[1]}" }
 #     $a.slice(2) |$first, $second| { notice "first ${first}, second ${second}" }
 #
 # When called without a block, the function produces a concatenated result of the slices.
 #
 # @example Using slice without a block
 #
 #     slice([1,2,3,4,5,6], 2) # produces [[1,2], [3,4], [5,6]]
 #     slice(Integer[1,6], 2)  # produces [[1,2], [3,4], [5,6]]
 #     slice(4,2)              # produces [[0,1], [2,3]]
 #     slice('hello',2)        # produces [[h, e], [l, l], [o]]
 #
-# @since 3.2 for Array and Hash
-# @since 3.5 for additional enumerable types
-# @note requires `parser = future`.
+# @since 4.0.0
 #
 Puppet::Functions.create_function(:slice) do
   dispatch :slice_Hash do
     param 'Hash[Any, Any]', :hash
     param 'Integer[1, default]', :slize_size
     optional_block_param
   end
 
   dispatch :slice_Enumerable do
     param 'Any', :enumerable
     param 'Integer[1, default]', :slize_size
     optional_block_param
   end
 
   def slice_Hash(hash, slice_size, pblock = nil)
     result = slice_Common(hash, slice_size, [], pblock)
     pblock ? hash : result
   end
 
   def slice_Enumerable(enumerable, slice_size, pblock = nil)
     enum = asserted_enumerable(enumerable)
     result = slice_Common(enum, slice_size, nil, pblock)
     pblock ? enumerable : result
   end
 
   def slice_Common(o, slice_size, filler, pblock)
     serving_size = asserted_slice_serving_size(pblock, slice_size)
 
     enumerator = o.each_slice(slice_size)
     result = []
     if serving_size == 1
       begin
         if pblock
           loop do
             pblock.call(nil, enumerator.next)
           end
         else
           loop do
             result << enumerator.next
           end
         end
       rescue StopIteration
       end
     else
       begin
         loop do
           a = enumerator.next
           if a.size < serving_size
             a = a.dup.fill(filler, a.length...serving_size)
           end
           pblock.call(nil, *a)
         end
       rescue StopIteration
       end
     end
     if pblock
       o
     else
       result
     end
   end
 
   def asserted_slice_serving_size(pblock, slice_size)
     if pblock
       serving_size = pblock.last_captures_rest? ? slice_size : pblock.parameter_count
     else
       serving_size = 1
     end
     if serving_size == 0
       raise ArgumentError, "slice(): block must define at least one parameter. Block has 0."
     end
     unless serving_size == 1 || serving_size == slice_size
       raise ArgumentError, "slice(): block must define one parameter, or " +
         "the same number of parameters as the given size of the slice (#{slice_size}). Block has #{serving_size}; "+
       pblock.parameter_names.join(', ')
     end
     serving_size
   end
 
   def asserted_enumerable(obj)
     unless enum = Puppet::Pops::Types::Enumeration.enumerator(obj)
       raise ArgumentError, ("#{self.class.name}(): wrong argument type (#{obj.class}; must be something enumerable.")
     end
     enum
   end
 
 end
diff --git a/lib/puppet/functions/with.rb b/lib/puppet/functions/with.rb
index 6dd51ec18..4cbc0ffa1 100644
--- a/lib/puppet/functions/with.rb
+++ b/lib/puppet/functions/with.rb
@@ -1,23 +1,23 @@
 # Call a lambda with the given arguments. Since the parameters of the lambda
 # are local to the lambda's scope, this can be used to create private sections
 # of logic in a class so that the variables are not visible outside of the
 # class.
 #
 # @example Using with
 #
 #     # notices the array [1, 2, 'foo']
 #     with(1, 2, 'foo') |$x, $y, $z| { notice [$x, $y, $z] }
 #
-# @since 3.7.0
+# @since 4.0.0
 #
 Puppet::Functions.create_function(:with) do
   dispatch :with do
     param 'Any', 'arg'
     arg_count(0, :default)
     required_block_param
   end
 
   def with(*args)
     args[-1].call({}, *args[0..-2])
   end
 end
diff --git a/lib/puppet/parser/ast/pops_bridge.rb b/lib/puppet/parser/ast/pops_bridge.rb
index 5efa8ad92..a248f8b41 100644
--- a/lib/puppet/parser/ast/pops_bridge.rb
+++ b/lib/puppet/parser/ast/pops_bridge.rb
@@ -1,243 +1,243 @@
 require 'puppet/parser/ast/top_level_construct'
 require 'puppet/pops'
 
 # The AST::Bridge contains classes that bridges between the new Pops based model
 # and the 3.x AST. This is required to be able to reuse the Puppet::Resource::Type which is
 # fundamental for the rest of the logic.
 #
 class Puppet::Parser::AST::PopsBridge
 
   # Bridges to one Pops Model Expression
   # The @value is the expression
   # This is used to represent the body of a class, definition, or node, and for each parameter's default value
   # expression.
   #
   class Expression < Puppet::Parser::AST::Leaf
 
     def initialize args
       super
       @@evaluator ||= Puppet::Pops::Parser::EvaluatingParser.new()
     end
 
     def to_s
       Puppet::Pops::Model::ModelTreeDumper.new.dump(@value)
     end
 
     def evaluate(scope)
       object = @@evaluator.evaluate(scope, @value)
       @@evaluator.convert_to_3x(object, scope)
     end
 
     # Adapts to 3x where top level constructs needs to have each to iterate over children. Short circuit this
     # by yielding self. By adding this there is no need to wrap a pops expression inside an AST::BlockExpression
     #
     def each
       yield self
     end
 
     def sequence_with(other)
       if value.nil?
         # This happens when testing and not having a complete setup
         other
       else
         # When does this happen ? Ever ?
         raise "sequence_with called on Puppet::Parser::AST::PopsBridge::Expression - please report use case"
         # What should be done if the above happens (We don't want this to happen).
         # Puppet::Parser::AST::BlockExpression.new(:children => [self] + other.children)
       end
     end
 
     # The 3x requires code plugged in to an AST to have this in certain positions in the tree. The purpose
     # is to either print the content, or to look for things that needs to be defined. This implementation
     # cheats by always returning an empty array. (This allows simple files to not require a "Program" at the top.
     #
     def children
       []
     end
   end
 
   # Bridges the top level "Program" produced by the pops parser.
   # Its main purpose is to give one point where all definitions are instantiated (actually defined since the
   # Puppet 3x terminology is somewhat misleading - the definitions are instantiated, but instances of the created types
   # are not created, that happens when classes are included / required, nodes are matched and when resources are instantiated
   # by a resource expression (which is also used to instantiate a host class).
   #
   class Program < Puppet::Parser::AST::TopLevelConstruct
     attr_reader :program_model, :context
 
     def initialize(program_model, context = {})
       @program_model = program_model
       @context = context
       @ast_transformer ||= Puppet::Pops::Model::AstTransformer.new(@context[:file])
       @@evaluator ||= Puppet::Pops::Parser::EvaluatingParser.new()
     end
 
     # This is the 3x API, the 3x AST searches through all code to find the instructions that can be instantiated.
     # This Pops-model based instantiation relies on the parser to build this list while parsing (which is more
     # efficient as it avoids one full scan of all logic via recursive enumeration/yield)
     #
     def instantiate(modname)
       @program_model.definitions.collect do |d|
         case d
         when Puppet::Pops::Model::HostClassDefinition
           instantiate_HostClassDefinition(d, modname)
         when Puppet::Pops::Model::ResourceTypeDefinition
           instantiate_ResourceTypeDefinition(d, modname)
         when Puppet::Pops::Model::NodeDefinition
           instantiate_NodeDefinition(d, modname)
         else
           raise Puppet::ParseError, "Internal Error: Unknown type of definition - got '#{d.class}'"
         end
       end.flatten().compact() # flatten since node definition may have returned an array
                               # Compact since functions are not understood by compiler
     end
 
     def evaluate(scope)
       @@evaluator.evaluate(scope, program_model)
     end
 
     # Adapts to 3x where top level constructs needs to have each to iterate over children. Short circuit this
     # by yielding self. This means that the HostClass container will call this bridge instance with `instantiate`.
     #
     def each
       yield self
     end
 
     private
 
     def instantiate_Parameter(o)
       # 3x needs parameters as an array of `[name]` or `[name, value_expr]`
       if o.value
         [o.name, Expression.new(:value => o.value)]
       else
         [o.name]
       end
     end
 
     def create_type_map(definition)
       result = {}
       # No need to do anything if there are no parameters
       return result unless definition.parameters.size > 0
 
       # No need to do anything if there are no typed parameters
       typed_parameters = definition.parameters.select {|p| p.type_expr }
       return result if typed_parameters.empty?
 
       # If there are typed parameters, they need to be evaluated to produce the corresponding type
       # instances. This evaluation requires a scope. A scope is not available when doing deserialization
       # (there is also no initialized evaluator). When running apply and test however, the environment is
       # reused and we may reenter without a scope (which is fine). A debug message is then output in case
       # there is the need to track down the odd corner case. See {#obtain_scope}.
       #
       if scope = obtain_scope
         typed_parameters.each do |p|
           result[p.name] =  @@evaluator.evaluate(scope, p.type_expr)
         end
       end
       result
     end
 
     # Obtains the scope or issues a warning if :global_scope is not bound
     def obtain_scope
       scope = Puppet.lookup(:global_scope) do
         # This occurs when testing and when applying a catalog (there is no scope available then), and
         # when running tests that run a partial setup.
         # This is bad if the logic is trying to compile, but a warning can not be issues since it is a normal
         # use case that there is no scope when requesting the type in order to just get the parameters.
         Puppet.debug("Instantiating Resource with type checked parameters - scope is missing, skipping type checking.")
         nil
       end
       scope
     end
 
     # Produces a hash with data for Definition and HostClass
     def args_from_definition(o, modname)
       args = {
        :arguments => o.parameters.collect {|p| instantiate_Parameter(p) },
        :argument_types => create_type_map(o),
        :module_name => modname
       }
       unless is_nop?(o.body)
         args[:code] = Expression.new(:value => o.body)
       end
       @ast_transformer.merge_location(args, o)
     end
 
     def instantiate_HostClassDefinition(o, modname)
       args = args_from_definition(o, modname)
       args[:parent] = absolute_reference(o.parent_class)
       Puppet::Resource::Type.new(:hostclass, o.name, @context.merge(args))
     end
 
     def instantiate_ResourceTypeDefinition(o, modname)
       Puppet::Resource::Type.new(:definition, o.name, @context.merge(args_from_definition(o, modname)))
     end
 
     def instantiate_NodeDefinition(o, modname)
       args = { :module_name => modname }
 
       unless is_nop?(o.body)
         args[:code] = Expression.new(:value => o.body)
       end
 
       unless is_nop?(o.parent)
         args[:parent] = @ast_transformer.hostname(o.parent)
       end
 
       host_matches = @ast_transformer.hostname(o.host_matches)
       @ast_transformer.merge_location(args, o)
       host_matches.collect do |name|
         Puppet::Resource::Type.new(:node, name, @context.merge(args))
       end
     end
 
     # Propagates a found Function to the appropriate loader.
-    # This is for 4x future-evaluator/loader
+    # This is for 4x evaluator/loader
     #
     def instantiate_FunctionDefinition(function_definition, modname)
       loaders = (Puppet.lookup(:loaders) { nil })
       unless loaders
         raise Puppet::ParseError, "Internal Error: Puppet Context ':loaders' missing - cannot define any functions"
       end
       loader =
       if modname.nil? || modname == ""
         # TODO : Later when functions can be private, a decision is needed regarding what that means.
         #        A private environment loader could be used for logic outside of modules, then only that logic
         #        would see the function.
         #
         # Use the private loader, this function may see the environment's dependencies (currently, all modules)
         loaders.private_environment_loader()
       else
         # TODO : Later check if function is private, and then add it to
         #        private_loader_for_module
         #
         loaders.public_loader_for_module(modname)
       end
       unless loader
         raise Puppet::ParseError, "Internal Error: did not find public loader for module: '#{modname}'"
       end
 
       # Instantiate Function, and store it in the environment loader
       typed_name, f = Puppet::Pops::Loader::PuppetFunctionInstantiator.create_from_model(function_definition, loader)
       loader.set_entry(typed_name, f, Puppet::Pops::Adapters::SourcePosAdapter.adapt(function_definition).to_uri)
 
       nil # do not want the function to inadvertently leak into 3x
     end
 
     def code()
       Expression.new(:value => @value)
     end
 
     def is_nop?(o)
       @ast_transformer.is_nop?(o)
     end
 
     def absolute_reference(ref)
       if ref.nil? || ref.empty? || ref.start_with?('::')
         ref
       else
         "::#{ref}"
       end
     end
   end
 end
diff --git a/lib/puppet/parser/compiler.rb b/lib/puppet/parser/compiler.rb
index f6b827b39..2a9616a71 100644
--- a/lib/puppet/parser/compiler.rb
+++ b/lib/puppet/parser/compiler.rb
@@ -1,611 +1,611 @@
 require 'forwardable'
 
 require 'puppet/node'
 require 'puppet/resource/catalog'
 require 'puppet/util/errors'
 
 require 'puppet/resource/type_collection_helper'
 require 'puppet/loaders'
 
 # Maintain a graph of scopes, along with a bunch of data
 # about the individual catalog we're compiling.
 class Puppet::Parser::Compiler
   extend Forwardable
 
   include Puppet::Util
   include Puppet::Util::Errors
   include Puppet::Util::MethodHelper
   include Puppet::Resource::TypeCollectionHelper
 
   def self.compile(node)
     $env_module_directories = nil
     node.environment.check_for_reparse
 
     errors = node.environment.validation_errors
     if !errors.empty?
       errors.each { |e| Puppet.err(e) } if errors.size > 1
       errmsg = [
         "Compilation has been halted because: #{errors.first}",
         "For more information, see http://docs.puppetlabs.com/puppet/latest/reference/environments.html",
       ]
       raise(Puppet::Error, errmsg.join(' '))
     end
 
     new(node).compile.to_resource
   rescue => detail
     message = "#{detail} on node #{node.name}"
     Puppet.log_exception(detail, message)
     raise Puppet::Error, message, detail.backtrace
  end
 
   attr_reader :node, :facts, :collections, :catalog, :resources, :relationships, :topscope
 
   # The injector that provides lookup services, or nil if accessed before the compiler has started compiling and
   # bootstrapped. The injector is initialized and available before any manifests are evaluated.
   #
   # @return [Puppet::Pops::Binder::Injector, nil] The injector that provides lookup services for this compiler/environment
   # @api public
   #
   attr_accessor :injector
 
   # Access to the configured loaders for 4x
   # @return [Puppet::Pops::Loader::Loaders] the configured loaders
   # @api private
   attr_reader :loaders
 
   # The injector that provides lookup services during the creation of the {#injector}.
   # @return [Puppet::Pops::Binder::Injector, nil] The injector that provides lookup services during injector creation
   #   for this compiler/environment
   #
   # @api private
   #
   attr_accessor :boot_injector
 
   # Add a collection to the global list.
   def_delegator :@collections,   :<<, :add_collection
   def_delegator :@relationships, :<<, :add_relationship
 
   # Store a resource override.
   def add_override(override)
     # If possible, merge the override in immediately.
     if resource = @catalog.resource(override.ref)
       resource.merge(override)
     else
       # Otherwise, store the override for later; these
       # get evaluated in Resource#finish.
       @resource_overrides[override.ref] << override
     end
   end
 
   def add_resource(scope, resource)
     @resources << resource
 
     # Note that this will fail if the resource is not unique.
     @catalog.add_resource(resource)
 
     if not resource.class? and resource[:stage]
       raise ArgumentError, "Only classes can set 'stage'; normal resources like #{resource} cannot change run stage"
     end
 
     # Stages should not be inside of classes.  They are always a
     # top-level container, regardless of where they appear in the
     # manifest.
     return if resource.stage?
 
     # This adds a resource to the class it lexically appears in in the
     # manifest.
     unless resource.class?
       return @catalog.add_edge(scope.resource, resource)
     end
   end
 
   # Do we use nodes found in the code, vs. the external node sources?
   def_delegator :known_resource_types, :nodes?, :ast_nodes?
 
   # Store the fact that we've evaluated a class
   def add_class(name)
     @catalog.add_class(name) unless name == ""
   end
 
 
   # Return a list of all of the defined classes.
   def_delegator :@catalog, :classes, :classlist
 
   # Compiler our catalog.  This mostly revolves around finding and evaluating classes.
   # This is the main entry into our catalog.
   def compile
     Puppet.override( @context_overrides , "For compiling #{node.name}") do
       @catalog.environment_instance = environment
 
       # Set the client's parameters into the top scope.
       Puppet::Util::Profiler.profile("Compile: Set node parameters", [:compiler, :set_node_params]) { set_node_parameters }
 
       Puppet::Util::Profiler.profile("Compile: Created settings scope", [:compiler, :create_settings_scope]) { create_settings_scope }
 
       activate_binder
 #        # create injector, if not already created - this is for 3x that does not trigger
 #        # lazy loading of injector via context
 #        Puppet::Util::Profiler.profile("Compile: Created injector", [:compiler, :create_injector]) { injector }
 #      end
 
       Puppet::Util::Profiler.profile("Compile: Evaluated main", [:compiler, :evaluate_main]) { evaluate_main }
 
       Puppet::Util::Profiler.profile("Compile: Evaluated AST node", [:compiler, :evaluate_ast_node]) { evaluate_ast_node }
 
       Puppet::Util::Profiler.profile("Compile: Evaluated node classes", [:compiler, :evaluate_node_classes]) { evaluate_node_classes }
 
       Puppet::Util::Profiler.profile("Compile: Evaluated generators", [:compiler, :evaluate_generators]) { evaluate_generators }
 
       Puppet::Util::Profiler.profile("Compile: Finished catalog", [:compiler, :finish_catalog]) { finish }
 
       fail_on_unevaluated
 
       @catalog
     end
   end
 
   # Constructs the overrides for the context
   def context_overrides()
     {
       :current_environment => environment,
       :global_scope => @topscope,             # 4x placeholder for new global scope
       :loaders  => lambda {|| loaders() },    # 4x loaders
       :injector => lambda {|| injector() }    # 4x API - via context instead of via compiler
     }
   end
 
   def_delegator :@collections, :delete, :delete_collection
 
   # Return the node's environment.
   def environment
     node.environment
   end
 
   # Evaluate all of the classes specified by the node.
   # Classes with parameters are evaluated as if they were declared.
   # Classes without parameters or with an empty set of parameters are evaluated
   # as if they were included. This means classes with an empty set of
   # parameters won't conflict even if the class has already been included.
   def evaluate_node_classes
     if @node.classes.is_a? Hash
       classes_with_params, classes_without_params = @node.classes.partition {|name,params| params and !params.empty?}
 
       # The results from Hash#partition are arrays of pairs rather than hashes,
       # so we have to convert to the forms evaluate_classes expects (Hash, and
       # Array of class names)
       classes_with_params = Hash[classes_with_params]
       classes_without_params.map!(&:first)
     else
       classes_with_params = {}
       classes_without_params = @node.classes
     end
 
     evaluate_classes(classes_with_params, @node_scope || topscope)
     evaluate_classes(classes_without_params, @node_scope || topscope)
   end
 
   # Evaluate each specified class in turn.  If there are any classes we can't
   # find, raise an error.  This method really just creates resource objects
   # that point back to the classes, and then the resources are themselves
   # evaluated later in the process.
   #
   # Sometimes we evaluate classes with a fully qualified name already, in which
   # case, we tell scope.find_hostclass we've pre-qualified the name so it
   # doesn't need to search its namespaces again.  This gets around a weird
   # edge case of duplicate class names, one at top scope and one nested in our
   # namespace and the wrong one (or both!) getting selected. See ticket #13349
   # for more detail.  --jeffweiss 26 apr 2012
   def evaluate_classes(classes, scope, lazy_evaluate = true, fqname = false)
     raise Puppet::DevError, "No source for scope passed to evaluate_classes" unless scope.source
     class_parameters = nil
     # if we are a param class, save the classes hash
     # and transform classes to be the keys
     if classes.class == Hash
       class_parameters = classes
       classes = classes.keys
     end
 
     hostclasses = classes.collect do |name|
       scope.find_hostclass(name, :assume_fqname => fqname) or raise Puppet::Error, "Could not find class #{name} for #{node.name}"
     end
 
     if class_parameters
       resources = ensure_classes_with_parameters(scope, hostclasses, class_parameters)
       if !lazy_evaluate
         resources.each(&:evaluate)
       end
 
       resources
     else
       already_included, newly_included = ensure_classes_without_parameters(scope, hostclasses)
       if !lazy_evaluate
         newly_included.each(&:evaluate)
       end
 
       already_included + newly_included
     end
   end
 
   def evaluate_relationships
     @relationships.each { |rel| rel.evaluate(catalog) }
   end
 
   # Return a resource by either its ref or its type and title.
   def_delegator :@catalog, :resource, :findresource
 
   def initialize(node, options = {})
     @node = node
     set_options(options)
     initvars
   end
 
   # Create a new scope, with either a specified parent scope or
   # using the top scope.
   def newscope(parent, options = {})
     parent ||= topscope
     scope = Puppet::Parser::Scope.new(self, options)
     scope.parent = parent
     scope
   end
 
   # Return any overrides for the given resource.
   def resource_overrides(resource)
     @resource_overrides[resource.ref]
   end
 
   def injector
     create_injector if @injector.nil?
     @injector
   end
 
   def loaders
     @loaders ||= Puppet::Pops::Loaders.new(environment)
   end
 
   def boot_injector
     create_boot_injector(nil) if @boot_injector.nil?
     @boot_injector
   end
 
   # Creates the boot injector from registered system, default, and injector config.
   # @return [Puppet::Pops::Binder::Injector] the created boot injector
   # @api private Cannot be 'private' since it is called from the BindingsComposer.
   #
   def create_boot_injector(env_boot_bindings)
     assert_binder_active()
     pb = Puppet::Pops::Binder
     boot_contribution = pb::SystemBindings.injector_boot_contribution(env_boot_bindings)
     final_contribution = pb::SystemBindings.final_contribution
     binder = pb::Binder.new(pb::BindingsFactory.layered_bindings(final_contribution, boot_contribution))
     @boot_injector = pb::Injector.new(binder)
   end
 
   # Answers if Puppet Binder should be active or not, and if it should and is not active, then it is activated.
   # @return [Boolean] true if the Puppet Binder should be activated
   def activate_binder
     # TODO: this should be in a central place
     Puppet::Parser::ParserFactory.assert_rgen_installed()
     @@binder_loaded ||= false
     unless @@binder_loaded
       require 'puppet/pops'
       require 'puppet/plugins/configuration'
       @@binder_loaded = true
     end
     true
   end
 
   private
 
   def ensure_classes_with_parameters(scope, hostclasses, parameters)
     hostclasses.collect do |klass|
       klass.ensure_in_catalog(scope, parameters[klass.name] || {})
     end
   end
 
   def ensure_classes_without_parameters(scope, hostclasses)
     already_included = []
     newly_included = []
     hostclasses.each do |klass|
       class_scope = scope.class_scope(klass)
       if class_scope
         already_included << class_scope.resource
       else
         newly_included << klass.ensure_in_catalog(scope)
       end
     end
 
     [already_included, newly_included]
   end
 
   # If ast nodes are enabled, then see if we can find and evaluate one.
   def evaluate_ast_node
     return unless ast_nodes?
 
     # Now see if we can find the node.
     astnode = nil
     @node.names.each do |name|
       break if astnode = known_resource_types.node(name.to_s.downcase)
     end
 
     unless (astnode ||= known_resource_types.node("default"))
       raise Puppet::ParseError, "Could not find default node or by name with '#{node.names.join(", ")}'"
     end
 
     # Create a resource to model this node, and then add it to the list
     # of resources.
     resource = astnode.ensure_in_catalog(topscope)
 
     resource.evaluate
 
     @node_scope = topscope.class_scope(astnode)
   end
 
   # Evaluate our collections and return true if anything returned an object.
   # The 'true' is used to continue a loop, so it's important.
   def evaluate_collections
     return false if @collections.empty?
 
     exceptwrap do
       # We have to iterate over a dup of the array because
       # collections can delete themselves from the list, which
       # changes its length and causes some collections to get missed.
       Puppet::Util::Profiler.profile("Evaluated collections", [:compiler, :evaluate_collections]) do
         found_something = false
         @collections.dup.each do |collection|
           found_something = true if collection.evaluate
         end
         found_something
       end
     end
   end
 
   # Make sure all of our resources have been evaluated into native resources.
   # We return true if any resources have, so that we know to continue the
   # evaluate_generators loop.
   def evaluate_definitions
     exceptwrap do
       Puppet::Util::Profiler.profile("Evaluated definitions", [:compiler, :evaluate_definitions]) do
         !unevaluated_resources.each do |resource|
           Puppet::Util::Profiler.profile("Evaluated resource #{resource}", [:compiler, :evaluate_resource, resource]) do
             resource.evaluate
           end
         end.empty?
       end
     end
   end
 
   # Iterate over collections and resources until we're sure that the whole
   # compile is evaluated.  This is necessary because both collections
   # and defined resources can generate new resources, which themselves could
   # be defined resources.
   def evaluate_generators
     count = 0
     loop do
       done = true
 
       Puppet::Util::Profiler.profile("Iterated (#{count + 1}) on generators", [:compiler, :iterate_on_generators]) do
         # Call collections first, then definitions.
         done = false if evaluate_collections
         done = false if evaluate_definitions
       end
 
       break if done
 
       count += 1
 
       if count > 1000
         raise Puppet::ParseError, "Somehow looped more than 1000 times while evaluating host catalog"
       end
     end
   end
 
   # Find and evaluate our main object, if possible.
   def evaluate_main
     @main = known_resource_types.find_hostclass([""], "") || known_resource_types.add(Puppet::Resource::Type.new(:hostclass, ""))
     @topscope.source = @main
     @main_resource = Puppet::Parser::Resource.new("class", :main, :scope => @topscope, :source => @main)
     @topscope.resource = @main_resource
 
     add_resource(@topscope, @main_resource)
 
     @main_resource.evaluate
   end
 
   # Make sure the entire catalog is evaluated.
   def fail_on_unevaluated
     fail_on_unevaluated_overrides
     fail_on_unevaluated_resource_collections
   end
 
   # If there are any resource overrides remaining, then we could
   # not find the resource they were supposed to override, so we
   # want to throw an exception.
   def fail_on_unevaluated_overrides
     remaining = @resource_overrides.values.flatten.collect(&:ref)
 
     if !remaining.empty?
       fail Puppet::ParseError,
         "Could not find resource(s) #{remaining.join(', ')} for overriding"
     end
   end
 
   # Make sure there are no remaining collections that are waiting for
   # resources that have not yet been instantiated. If this occurs it
   # is an error (missing resourcei - it could not be realized).
   #
   def fail_on_unevaluated_resource_collections
     remaining = @collections.collect(&:unresolved_resources).flatten.compact
     if !remaining.empty?
       raise Puppet::ParseError, "Failed to realize virtual resources #{remaining.join(', ')}"
     end
   end
 
   # Make sure all of our resources and such have done any last work
   # necessary.
   def finish
     evaluate_relationships
 
     resources.each do |resource|
       # Add in any resource overrides.
       if overrides = resource_overrides(resource)
         overrides.each do |over|
           resource.merge(over)
         end
 
         # Remove the overrides, so that the configuration knows there
         # are none left.
         overrides.clear
       end
 
       resource.finish if resource.respond_to?(:finish)
     end
 
     add_resource_metaparams
   end
 
   def add_resource_metaparams
     unless main = catalog.resource(:class, :main)
       raise "Couldn't find main"
     end
 
     names = Puppet::Type.metaparams.select do |name|
       !Puppet::Parser::Resource.relationship_parameter?(name)
     end
 
     data = {}
     catalog.walk(main, :out) do |source, target|
       if source_data = data[source] || metaparams_as_data(source, names)
         # only store anything in the data hash if we've actually got
         # data
         data[source] ||= source_data
         source_data.each do |param, value|
           target[param] = value if target[param].nil?
         end
         data[target] = source_data.merge(metaparams_as_data(target, names))
       end
 
       target.tag(*(source.tags))
     end
   end
 
   def metaparams_as_data(resource, params)
     data = nil
     params.each do |param|
       unless resource[param].nil?
         # Because we could be creating a hash for every resource,
         # and we actually probably don't often have any data here at all,
         # we're optimizing a bit by only creating a hash if there's
         # any data to put in it.
         data ||= {}
         data[param] = resource[param]
       end
     end
     data
   end
 
   # Set up all of our internal variables.
   def initvars
     # The list of overrides.  This is used to cache overrides on objects
     # that don't exist yet.  We store an array of each override.
     @resource_overrides = Hash.new do |overs, ref|
       overs[ref] = []
     end
 
     # The list of collections that have been created.  This is a global list,
     # but they each refer back to the scope that created them.
     @collections = []
 
     # The list of relationships to evaluate.
     @relationships = []
 
     # For maintaining the relationship between scopes and their resources.
     @catalog = Puppet::Resource::Catalog.new(@node.name, @node.environment)
 
     # MOVED HERE - SCOPE IS NEEDED (MOVE-SCOPE)
     # Create the initial scope, it is needed early
     @topscope = Puppet::Parser::Scope.new(self)
 
     # Need to compute overrides here, and remember them, because we are about to
     # enter the magic zone of known_resource_types and initial import.
     # Expensive entries in the context are bound lazily.
     @context_overrides = context_overrides()
 
     # This construct ensures that initial import (triggered by instantiating
     # the structure 'known_resource_types') has a configured context
     # It cannot survive the initvars method, and is later reinstated
     # as part of compiling...
     #
     Puppet.override( @context_overrides , "For initializing compiler") do
       # THE MAGIC STARTS HERE ! This triggers parsing, loading etc.
       @catalog.version = known_resource_types.version
     end
 
     @catalog.add_resource(Puppet::Parser::Resource.new("stage", :main, :scope => @topscope))
 
     # local resource array to maintain resource ordering
     @resources = []
 
     # Make sure any external node classes are in our class list
     if @node.classes.class == Hash
       @catalog.add_class(*@node.classes.keys)
     else
       @catalog.add_class(*@node.classes)
     end
   end
 
   # Set the node's parameters into the top-scope as variables.
   def set_node_parameters
     node.parameters.each do |param, value|
       @topscope[param.to_s] = value
     end
     # These might be nil.
     catalog.client_version = node.parameters["clientversion"]
     catalog.server_version = node.parameters["serverversion"]
     @topscope.set_trusted(node.trusted_data)
     facts_hash = node.facts.nil? ? {} : node.facts.values
     @topscope.set_facts(facts_hash)
   end
 
   def create_settings_scope
     settings_type = Puppet::Resource::Type.new :hostclass, "settings"
     environment.known_resource_types.add(settings_type)
 
     settings_resource = Puppet::Parser::Resource.new("class", "settings", :scope => @topscope)
 
     @catalog.add_resource(settings_resource)
 
     settings_type.evaluate_code(settings_resource)
 
     scope = @topscope.class_scope(settings_type)
 
     env = environment
     Puppet.settings.each do |name, setting|
       next if name == :name
       scope[name.to_s] = env[name]
     end
   end
 
   # Return an array of all of the unevaluated resources.  These will be definitions,
   # which need to get evaluated into native resources.
   def unevaluated_resources
     # The order of these is significant for speed due to short-circuting
     resources.reject { |resource| resource.evaluated? or resource.virtual? or resource.builtin_type? }
   end
 
   # Creates the injector from bindings found in the current environment.
   # @return [void]
   # @api private
   #
   def create_injector
     assert_binder_active()
     composer = Puppet::Pops::Binder::BindingsComposer.new()
     layered_bindings = composer.compose(topscope)
     @injector = Puppet::Pops::Binder::Injector.new(Puppet::Pops::Binder::Binder.new(layered_bindings))
   end
 
   def assert_binder_active
     unless activate_binder()
-      raise ArgumentError, "The Puppet Binder is only available when either '--binder true' or '--parser future' is used"
+      raise Puppet::DevError, "The Puppet Binder was not activated"
     end
   end
 end
diff --git a/lib/puppet/parser/functions/assert_type.rb b/lib/puppet/parser/functions/assert_type.rb
index 577697420..bf4ea34a6 100644
--- a/lib/puppet/parser/functions/assert_type.rb
+++ b/lib/puppet/parser/functions/assert_type.rb
@@ -1,31 +1,30 @@
 Puppet::Parser::Functions::newfunction(
   :assert_type,
   :type => :rvalue,
   :arity => -3,
   :doc => "Returns the given value if it is an instance of the given type, and raises an error otherwise.
 Optionally, if a block is given (accepting two parameters), it will be called instead of raising
 an error. This to enable giving the user richer feedback, or to supply a default value.
 
 Example: assert that `$b` is a non empty `String` and assign to `$a`:
 
   $a = assert_type(String[1], $b)
 
 Example using custom error message:
 
   $a = assert_type(String[1], $b) |$expected, $actual| {
     fail('The name cannot be empty')
   }
 
 Example, using a warning and a default:
 
   $a = assert_type(String[1], $b) |$expected, $actual| {
     warning('Name is empty, using default')
     'anonymous'
   }
 
 See the documentation for 'The Puppet Type System' for more information about types.
-- since Puppet 3.7
-- requires future parser/evaluator
+- Since 4.0.0
 ") do |args|
   function_fail(["assert_type() is only available when parser/evaluator future is in effect"])
 end
diff --git a/lib/puppet/parser/functions/contain.rb b/lib/puppet/parser/functions/contain.rb
index 9c9447661..8628d9dd2 100644
--- a/lib/puppet/parser/functions/contain.rb
+++ b/lib/puppet/parser/functions/contain.rb
@@ -1,36 +1,38 @@
 # Called within a class definition, establishes a containment
 # relationship with another class
 
 Puppet::Parser::Functions::newfunction(
   :contain,
   :arity => -2,
   :doc => "Contain one or more classes inside the current class. If any of
 these classes are undeclared, they will be declared as if called with the
 `include` function. Accepts a class name, an array of class names, or a
 comma-separated list of class names.
 
 A contained class will not be applied before the containing class is
 begun, and will be finished before the containing class is finished.
 
-When the future parser is used, you must use the class's full name;
-relative names are no longer allowed. In addition to names in string form,
+You must use the class's full name;
+relative names are not allowed. In addition to names in string form,
 you may also directly use Class and Resource Type values that are produced by
-the future parser's resource and relationship expressions.
+evaluating resource and relationship expressions.
+
+- Since 4.0.0 support for Class and Resource Type values, absolute names
 "
 ) do |classes|
   scope = self
 
   # Make call patterns uniform and protected against nested arrays, also make
   # names absolute if so desired.
   classes = transform_and_assert_classnames(classes.is_a?(Array) ? classes.flatten : [classes])
 
   containing_resource = scope.resource
 
   # This is the same as calling the include function but faster and does not rely on the include
   # function (which is a statement) to return something (it should not).
   (compiler.evaluate_classes(classes, self, false) || []).each do |resource|
     if ! scope.catalog.edge?(containing_resource, resource)
       scope.catalog.add_edge(containing_resource, resource)
     end
   end
 end
diff --git a/lib/puppet/parser/functions/defined.rb b/lib/puppet/parser/functions/defined.rb
index 5ed0da0d7..cccb2a207 100644
--- a/lib/puppet/parser/functions/defined.rb
+++ b/lib/puppet/parser/functions/defined.rb
@@ -1,68 +1,70 @@
 # Test whether a given class or definition is defined
-Puppet::Parser::Functions::newfunction(:defined, :type => :rvalue, :arity => -2, :doc => "Determine whether
+Puppet::Parser::Functions::newfunction(:defined, :type => :rvalue, :arity => -2,
+  :doc => "Determine whether
   a given class or resource type is defined. This function can also determine whether a
   specific resource has been defined, or whether a variable has been assigned a value
-  (including undef...as opposed to never having been assigned anything). Returns `true`
+  (including `undef` - as opposed to never having been assigned anything). Returns `true`
   or `false`. Accepts class names, type names, resource references, and variable
-  reference strings of the form `'$name'`.  When more than one argument is
-  supplied, defined() returns `true` if any are defined.
+  reference strings of the form `'$name'`. When more than one argument is
+  supplied, `defined()` returns `true` if any are defined.
 
   The `defined` function checks both native and defined types, including types
   provided as plugins via modules. Types and classes are both checked using their names:
 
       defined(\"file\")
       defined(\"customtype\")
       defined(\"foo\")
       defined(\"foo::bar\")
       defined(\'$name\')
 
   Resource declarations are checked using resource references, e.g.
   `defined( File['/tmp/myfile'] )`. Checking whether a given resource
   has been declared is, unfortunately, dependent on the evaluation order of
   the configuration, and the following code will not work:
 
       if defined(File['/tmp/foo']) {
           notify { \"This configuration includes the /tmp/foo file.\":}
       }
       file { \"/tmp/foo\":
           ensure => present,
       }
 
   However, this order requirement refers to evaluation order only, and ordering of
   resources in the configuration graph (e.g. with `before` or `require`) does not
   affect the behavior of `defined`.
 
   You may also search using types:
 
       defined(Resource[\'file\',\'/some/file\'])
       defined(File[\'/some/file\'])
       defined(Class[\'foo\'])
 
  - Since 2.7.0
- - Since 3.6.0 variable reference and future parser types") do |vals|
+ - Since 3.6.0 variable reference and future parser types
+ - Since 4.0.0") do |vals|
   vals = [vals] unless vals.is_a?(Array)
   vals.any? do |val|
     case val
     when String
       if m = /^\$(.+)$/.match(val)
         exist?(m[1])
       else
         find_resource_type(val) || find_definition(val) or find_hostclass(val)
       end
     when Puppet::Resource
       compiler.findresource(val.type, val.title)
     when Puppet::Pops::Types::PResourceType
       raise ArgumentError, "The given resource type is a reference to all kind of types" if val.type_name.nil?
       if val.title.nil?
         find_builtin_resource_type(val.type_name) || find_definition(val.type_name)
       else
         compiler.findresource(val.type_name, val.title)
       end
     when Puppet::Pops::Types::PHostClassType
       raise  ArgumentError, "The given class type is a reference to all classes" if val.class_name.nil?
       find_hostclass(val.class_name)
     else
       raise ArgumentError, "Invalid argument of type '#{val.class}' to 'defined'"
     end
   end
 end
diff --git a/lib/puppet/parser/functions/each.rb b/lib/puppet/parser/functions/each.rb
index 3f4437eef..2c983354e 100644
--- a/lib/puppet/parser/functions/each.rb
+++ b/lib/puppet/parser/functions/each.rb
@@ -1,48 +1,46 @@
 Puppet::Parser::Functions::newfunction(
   :each,
   :type => :rvalue,
   :arity => -3,
   :doc => <<-DOC
 Applies a parameterized block to each element in a sequence of selected entries from the first
 argument and returns the first argument.
 
 This function takes two mandatory arguments: the first should be an Array or a Hash or something that is
 of enumerable type (integer, Integer range, or String), and the second
 a parameterized block as produced by the puppet syntax:
 
       $a.each |$x| { ... }
       each($a) |$x| { ... }
 
 When the first argument is an Array (or of enumerable type other than Hash), the parameterized block
 should define one or two block parameters.
 For each application of the block, the next element from the array is selected, and it is passed to
 the block if the block has one parameter. If the block has two parameters, the first is the elements
 index, and the second the value. The index starts from 0.
 
       $a.each |$index, $value| { ... }
       each($a) |$index, $value| { ... }
 
 When the first argument is a Hash, the parameterized block should define one or two parameters.
 When one parameter is defined, the iteration is performed with each entry as an array of `[key, value]`,
 and when two parameters are defined the iteration is performed with key and value.
 
       $a.each |$entry|       { ..."key ${$entry[0]}, value ${$entry[1]}" }
       $a.each |$key, $value| { ..."key ${key}, value ${value}" }
 
 Example using each:
 
       [1,2,3].each |$val| { ... }                       # 1, 2, 3
       [5,6,7].each |$index, $val| { ... }               # (0, 5), (1, 6), (2, 7)
       {a=>1, b=>2, c=>3}].each |$val| { ... }           # ['a', 1], ['b', 2], ['c', 3]
       {a=>1, b=>2, c=>3}.each |$key, $val| { ... }      # ('a', 1), ('b', 2), ('c', 3)
       Integer[ 10, 20 ].each |$index, $value| { ... }   # (0, 10), (1, 11) ...
       "hello".each |$char| { ... }                      # 'h', 'e', 'l', 'l', 'o'
       3.each |$number| { ... }                          # 0, 1, 2
 
-- since 3.2 for Array and Hash
-- since 3.5 for other enumerables
-- note requires `parser = future`
+- Since 4.0.0
 DOC
 ) do |args|
   function_fail(["each() is only available when parser/evaluator future is in effect"])
 end
diff --git a/lib/puppet/parser/functions/epp.rb b/lib/puppet/parser/functions/epp.rb
index 5127aec71..9fe669f56 100644
--- a/lib/puppet/parser/functions/epp.rb
+++ b/lib/puppet/parser/functions/epp.rb
@@ -1,45 +1,44 @@
 Puppet::Parser::Functions::newfunction(:epp, :type => :rvalue, :arity => -2, :doc =>
 "Evaluates an Embedded Puppet Template (EPP) file and returns the rendered text result as a String.
 
 The first argument to this function should be a `<MODULE NAME>/<TEMPLATE FILE>`
 reference, which will load `<TEMPLATE FILE>` from a module's `templates`
 directory. (For example, the reference `apache/vhost.conf.epp` will load the
 file `<MODULES DIRECTORY>/apache/templates/vhost.conf.epp`.)
 
 The second argument is optional; if present, it should be a hash containing parameters for the
 template. (See below.)
 
 EPP supports the following tags:
 
 * `<%= puppet expression %>` - This tag renders the value of the expression it contains.
 * `<% puppet expression(s) %>` - This tag will execute the expression(s) it contains, but renders nothing.
 * `<%# comment %>` - The tag and its content renders nothing.
 * `<%%` or `%%>` - Renders a literal `<%` or `%>` respectively.
 * `<%-` - Same as `<%` but suppresses any leading whitespace.
 * `-%>` - Same as `%>` but suppresses any trailing whitespace on the same line (including line break).
 * `<%- |parameters| -%>` - When placed as the first tag declares the template's parameters.
 
 File based EPP supports the following visibilities of variables in scope:
 
 * Global scope (i.e. top + node scopes) - global scope is always visible
 * Global + all given arguments - if the EPP template does not declare parameters, and arguments are given
 * Global + declared parameters - if the EPP declares parameters, given argument names must match
 
 EPP supports parameters by placing an optional parameter list as the very first element in the EPP. As an example,
 `<%- |$x, $y, $z = 'unicorn'| -%>` when placed first in the EPP text declares that the parameters `x` and `y` must be
 given as template arguments when calling `inline_epp`, and that `z` if not given as a template argument
 defaults to `'unicorn'`. Template parameters are available as variables, e.g.arguments `$x`, `$y` and `$z` in the example.
 Note that `<%-` must be used or any leading whitespace will be interpreted as text
 
 Arguments are passed to the template by calling `epp` with a Hash as the last argument, where parameters
 are bound to values, e.g. `epp('...', {'x'=>10, 'y'=>20})`. Excess arguments may be given
 (i.e. undeclared parameters) only if the EPP templates does not declare any parameters at all.
 Template parameters shadow variables in outer scopes. File based epp does never have access to variables in the
 scope where the `epp` function is called from.
 
 - See function inline_epp for examples of EPP
-- Since 3.5
-- Requires Future Parser") do |args|
+- Since 4.0.0") do |args|
 
   function_fail(["epp() is only available when parser/evaluator future is in effect"])
 end
diff --git a/lib/puppet/parser/functions/filter.rb b/lib/puppet/parser/functions/filter.rb
index 365de9fcf..f67fe7159 100644
--- a/lib/puppet/parser/functions/filter.rb
+++ b/lib/puppet/parser/functions/filter.rb
@@ -1,44 +1,42 @@
 Puppet::Parser::Functions::newfunction(
   :filter,
   :arity => -3,
   :doc => <<-DOC
  Applies a parameterized block to each element in a sequence of entries from the first
  argument and returns an array or hash (same type as left operand for array/hash, and array for
  other enumerable types) with the entries for which the block evaluates to `true`.
 
  This function takes two mandatory arguments: the first should be an Array, a Hash, or an
  Enumerable object (integer, Integer range, or String),
  and the second a parameterized block as produced by the puppet syntax:
 
        $a.filter |$x| { ... }
        filter($a) |$x| { ... }
 
  When the first argument is something other than a Hash, the block is called with each entry in turn.
  When the first argument is a Hash the entry is an array with `[key, value]`.
 
  Example Using filter with one parameter
 
        # selects all that end with berry
        $a = ["raspberry", "blueberry", "orange"]
        $a.filter |$x| { $x =~ /berry$/ }          # rasberry, blueberry
 
  If the block defines two parameters, they will be set to `index, value` (with index starting at 0) for all
  enumerables except Hash, and to `key, value` for a Hash.
 
 Example Using filter with two parameters
 
      # selects all that end with 'berry' at an even numbered index
      $a = ["raspberry", "blueberry", "orange"]
      $a.filter |$index, $x| { $index % 2 == 0 and $x =~ /berry$/ } # raspberry
 
      # selects all that end with 'berry' and value >= 1
      $a = {"raspberry"=>0, "blueberry"=>1, "orange"=>1}
      $a.filter |$key, $x| { $x =~ /berry$/ and $x >= 1 } # blueberry
 
-- since 3.4 for Array and Hash
-- since 3.5 for other enumerables
-- note requires `parser = future`
+- Since 4.0.0
 DOC
 ) do |args|
   function_fail(["filter() is only available when parser/evaluator future is in effect"])
 end
diff --git a/lib/puppet/parser/functions/include.rb b/lib/puppet/parser/functions/include.rb
index 2bebbba8b..dab760307 100644
--- a/lib/puppet/parser/functions/include.rb
+++ b/lib/puppet/parser/functions/include.rb
@@ -1,35 +1,37 @@
 # Include the specified classes
 Puppet::Parser::Functions::newfunction(:include, :arity => -2, :doc =>
 "Declares one or more classes, causing the resources in them to be
 evaluated and added to the catalog. Accepts a class name, an array of class
 names, or a comma-separated list of class names.
 
 The `include` function can be used multiple times on the same class and will
 only declare a given class once. If a class declared with `include` has any
 parameters, Puppet will automatically look up values for them in Hiera, using
 `<class name>::<parameter name>` as the lookup key.
 
 Contrast this behavior with resource-like class declarations
 (`class {'name': parameter => 'value',}`), which must be used in only one place
 per class and can directly set parameters. You should avoid using both `include`
 and resource-like declarations with the same class.
 
 The `include` function does not cause classes to be contained in the class
 where they are declared. For that, see the `contain` function. It also
 does not create a dependency relationship between the declared class and the
 surrounding class; for that, see the `require` function.
 
-When the future parser is used, you must use the class's full name;
-relative names are no longer allowed. In addition to names in string form,
+You must use the class's full name;
+relative names are not allowed. In addition to names in string form,
 you may also directly use Class and Resource Type values that are produced by
 the future parser's resource and relationship expressions.
 
+- Since < 3.0.0
+- Since 4.0.0 support for class and resource type values, absolute names
 ") do |vals|
 
   # Unify call patterns (if called with nested arrays), make names absolute if
   # wanted and evaluate the classes
   compiler.evaluate_classes(
   transform_and_assert_classnames(
       vals.is_a?(Array) ? vals.flatten : [vals]),
       self, false)
 end
diff --git a/lib/puppet/parser/functions/lookup.rb b/lib/puppet/parser/functions/lookup.rb
index d7f2d16e3..b7c88cdfa 100644
--- a/lib/puppet/parser/functions/lookup.rb
+++ b/lib/puppet/parser/functions/lookup.rb
@@ -1,141 +1,142 @@
 Puppet::Parser::Functions.newfunction(:lookup, :type => :rvalue, :arity => -2, :doc => <<-'ENDHEREDOC') do |args|
 Looks up data defined using Puppet Bindings and Hiera.
 The function is callable with one to three arguments and optionally with a code block to further process the result.
 
 The lookup function can be called in one of these ways:
 
     lookup(name)
     lookup(name, type)
     lookup(name, type, default)
     lookup(options_hash)
     lookup(name, options_hash)
 
 The function may optionally be called with a code block / lambda with the following signatures:
 
     lookup(...) |$result| { ... }
     lookup(...) |$name, $result| { ... }
     lookup(...) |$name, $result, $default| { ... }
 
 The longer signatures are useful when the block needs to raise an error (it can report the name), or
 if it needs to know if the given default value was selected.
 
 The code block receives the following three arguments:
 
 * The `$name` is the last name that was looked up (*the* name if only one name was looked up)
 * The `$result` is the looked up value (or the default value if not found).
 * The `$default` is the given default value (`undef` if not given).
 
 The block, if present, is called with the result from the lookup. The value produced by the block is also what is
 produced by the `lookup` function.
 When a block is used, it is the users responsibility to call `error` if the result does not meet additional
 criteria, or if an undef value is not acceptable. If a value is not found, and a default has been
 specified, the default value is given to the block.
 
 The content of the options hash is:
 
 * `name` - The name or array of names to lookup (first found is returned)
 * `type` - The type to assert (a Type or a type specification in string form)
 * `default` - The default value if there was no value found (must comply with the data type)
 * `accept_undef` - (default `false`) An `undef` result is accepted if this options is set to `true`.
 * `override` - a hash with map from names to values that are used instead of the underlying bindings. If the name
   is found here it wins. Defaults to an empty hash.
 * `extra` - a hash with map from names to values that are used as a last resort to obtain a value. Defaults to an
   empty hash.
 
 When the call is on the form `lookup(name, options_hash)`, or `lookup(name, type, options_hash)`, the given name
 argument wins over the `options_hash['name']`.
 
 The search order is `override` (if given), then `binder`, then `hiera` and finally `extra` (if given). The first to produce
 a value other than undef for a given name wins.
 
 The type specification is one of:
 
   * A type in the Puppet Type System, e.g.:
     * `Integer`, an integral value with optional range e.g.:
       * `Integer[0, default]` - 0 or positive
       * `Integer[default, -1]` - negative, 
       * `Integer[1,100]` - value between 1 and 100 inclusive
     * `String`- any string
     * `Float` - floating point number (same signature as for Integer for `Integer` ranges)
     * `Boolean` - true of false (strict)
     * `Array` - an array (of Data by default), or parameterized as `Array[<element_type>]`, where
       `<element_type>` is the expected type of elements
     * `Hash`,  - a hash (of default `Literal` keys and `Data` values), or parameterized as
       `Hash[<value_type>]`, `Hash[<key_type>, <value_type>]`, where `<key_type>`, and
       `<value_type>` are the types of the keys and values respectively
       (key is `Literal` by default).
     * `Data` - abstract type representing any `Literal`, `Array[Data]`, or `Hash[Literal, Data]`
     * `Pattern[<p1>, <p2>, ..., <pn>]` - an enumeration of valid patterns (one or more) where
        a pattern is a regular expression string or regular expression,
        e.g. `Pattern['.com$', '.net$']`, `Pattern[/[a-z]+[0-9]+/]` 
     * `Enum[<s1>, <s2>, ..., <sn>]`, - an enumeration of exact string values (one or more)
        e.g. `Enum[blue, red, green]`.
     * `Variant[<t1>, <t2>,...<tn>]` - matches one of the listed types (at least one must be given)
       e.g. `Variant[Integer[8000,8999], Integer[20000, 99999]]` to accept a value in either range
     * `Regexp`- a regular expression (i.e. the result is a regular expression, not a string
        matching a regular expression).
   * A string containing a type description - one of the types as shown above but in string form.
 
 If the function is called without specifying a default value, and nothing is bound to the given name 
 an error is raised unless the option `accept_undef` is true. If a block is given it must produce an acceptable
 value (or call `error`). If the block does not produce an acceptable value an error is
 raised.
 
 Examples:
 
 When called with one argument; **the name**, it
 returns the bound value with the given name after having  asserted it has the default datatype `Data`:
 
     lookup('the_name')
 
 When called with two arguments; **the name**, and **the expected type**, it
 returns the bound value with the given name after having asserted it has the given data
 type ('String' in the example):
 
     lookup('the_name', 'String') # 3.x
     lookup('the_name', String)   # parser future
 
 When called with three arguments, **the name**, the **expected type**, and a **default**, it
 returns the bound value with the given name, or the default after having asserted the value
 has the given data type (`String` in the example above):
 
     lookup('the_name', 'String', 'Fred') # 3x
     lookup('the_name', String, 'Fred')   # parser future
 
 Using a lambda to process the looked up result - asserting that it starts with an upper case letter:
 
     # only with parser future
     lookup('the_size', Integer[1,100]) |$result| {
       if $large_value_allowed and $result > 10
         { error 'Values larger than 10 are not allowed'}
       $result
     }
 
 Including the name in the error
 
-    # only with parser future
+    # only since 4.0.0 or with 3x parser future,
     lookup('the_size', Integer[1,100]) |$name, $result| {
       if $large_value_allowed and $result > 10
         { error 'The bound value for '${name}' can not be larger than 10 in this configuration'}
       $result
     }
 
 When using a block, the value it produces is also asserted against the given type, and it may not be
 `undef` unless the option `'accept_undef'` is `true`.
 
 All options work as the corresponding (direct) argument. The `first_found` option and
 `accept_undef` are however only available as options.
 
 Using first_found semantics option to return the first name that has a bound value:
 
     lookup(['apache::port', 'nginx::port'], 'Integer', 80)
 
 If you want to make lookup return undef when no value was found instead of raising an error:
 
      $are_you_there = lookup('peekaboo', { accept_undef => true} )
      $are_you_there = lookup('peekaboo', { accept_undef => true}) |$result| { $result }
 
+- Since 4.0.0
 ENDHEREDOC
 
   Puppet::Pops::Binder::Lookup.lookup(self, args)
 end
diff --git a/lib/puppet/parser/functions/map.rb b/lib/puppet/parser/functions/map.rb
index c2ca3aae6..e5507a43b 100644
--- a/lib/puppet/parser/functions/map.rb
+++ b/lib/puppet/parser/functions/map.rb
@@ -1,43 +1,41 @@
 Puppet::Parser::Functions::newfunction(
   :map,
   :type => :rvalue,
   :arity => -3,
   :doc => <<-DOC
 Applies a parameterized block to each element in a sequence of entries from the first
 argument and returns an array with the result of each invocation of the parameterized block.
 
 This function takes two mandatory arguments: the first should be an Array, Hash, or of Enumerable type
 (integer, Integer range, or String), and the second a parameterized block as produced by the puppet syntax:
 
       $a.map |$x| { ... }
       map($a) |$x| { ... }
 
 When the first argument `$a` is an Array or of enumerable type, the block is called with each entry in turn.
 When the first argument is a hash the entry is an array with `[key, value]`.
 
 Example Using map with two arguments
 
      # Turns hash into array of values
      $a.map |$x|{ $x[1] }
 
      # Turns hash into array of keys
      $a.map |$x| { $x[0] }
 
 When using a block with 2 parameters, the element's index (starting from 0) for an array, and the key for a hash
 is given to the block's first parameter, and the value is given to the block's second parameter.args.
 
 Example Using map with two arguments
 
      # Turns hash into array of values
      $a.map |$key,$val|{ $val }
 
      # Turns hash into array of keys
      $a.map |$key,$val|{ $key }
 
-- since 3.4 for Array and Hash
-- since 3.5 for other enumerables, and support for blocks with 2 parameters
-- note requires `parser = future`
+- Since 4.0.0
 DOC
 ) do |args|
   function_fail(["map() is only available when parser/evaluator future is in effect"])
 end
diff --git a/lib/puppet/parser/functions/match.rb b/lib/puppet/parser/functions/match.rb
index 33bdf3e88..9627b84f5 100644
--- a/lib/puppet/parser/functions/match.rb
+++ b/lib/puppet/parser/functions/match.rb
@@ -1,28 +1,27 @@
 Puppet::Parser::Functions::newfunction(
   :match,
   :arity => 2,
   :doc => <<-DOC
 Returns the match result of matching a String or Array[String] with one of:
 
 * Regexp
 * String - transformed to a Regexp
 * Pattern type
 * Regexp type
 
 Returns An Array with the entire match at index 0, and each subsequent submatch at index 1-n.
 If there was no match `undef` is returned. If the value to match is an Array, a array
 with mapped match results is returned.
 
 Example matching:
 
   "abc123".match(/([a-z]+)[1-9]+/)    # => ["abc"]
   "abc123".match(/([a-z]+)([1-9]+)/)  # => ["abc", "123"]
 
 See the documentation for "The Puppet Type System" for more information about types.
 
-- since 3.7.0
-- note requires future parser
+- Since 4.0.0
 DOC
 ) do |args|
   function_fail(["match() is only available when parser/evaluator future is in effect"])
 end
diff --git a/lib/puppet/parser/functions/reduce.rb b/lib/puppet/parser/functions/reduce.rb
index 4fe90a239..83bed8b68 100644
--- a/lib/puppet/parser/functions/reduce.rb
+++ b/lib/puppet/parser/functions/reduce.rb
@@ -1,71 +1,69 @@
 Puppet::Parser::Functions::newfunction(
   :reduce,
   :type => :rvalue,
   :arity => -3,
   :doc => <<-DOC
 Applies a parameterized block to each element in a sequence of entries from the first
 argument (_the enumerable_) and returns the last result of the invocation of the parameterized block.
 
 This function takes two mandatory arguments: the first should be an Array, Hash, or something of
 enumerable type, and the last a parameterized block as produced by the puppet syntax:
 
       $a.reduce |$memo, $x| { ... }
       reduce($a) |$memo, $x| { ... }
 
 When the first argument is an Array or someting of an enumerable type, the block is called with each entry in turn.
 When the first argument is a hash each entry is converted to an array with `[key, value]` before being
 fed to the block. An optional 'start memo' value may be supplied as an argument between the array/hash
 and mandatory block.
 
       $a.reduce(start) |$memo, $x| { ... }
       reduce($a, start) |$memo, $x| { ... }
 
 If no 'start memo' is given, the first invocation of the parameterized block will be given the first and second
 elements of the enumeration, and if the enumerable has fewer than 2 elements, the first
 element is produced as the result of the reduction without invocation of the block.
 
 On each subsequent invocation, the produced value of the invoked parameterized block is given as the memo in the
 next invocation.
 
 Example Using reduce
 
       # Reduce an array
       $a = [1,2,3]
       $a.reduce |$memo, $entry| { $memo + $entry }
       #=> 6
 
       # Reduce hash values
       $a = {a => 1, b => 2, c => 3}
       $a.reduce |$memo, $entry| { [sum, $memo[1]+$entry[1]] }
       #=> [sum, 6]
 
       # reverse a string
       "abc".reduce |$memo, $char| { "$char$memo" }
       #=>"cbe"
 
 It is possible to provide a starting 'memo' as an argument.
 
 Example Using reduce with given start 'memo'
 
       # Reduce an array
       $a = [1,2,3]
       $a.reduce(4) |$memo, $entry| { $memo + $entry }
       #=> 10
 
       # Reduce hash values
       $a = {a => 1, b => 2, c => 3}
       $a.reduce([na, 4]) |$memo, $entry| { [sum, $memo[1]+$entry[1]] }
       #=> [sum, 10]
 
 Example Using reduce with an Integer range
 
       Integer[1,4].reduce |$memo, $x| { $memo + $x }
       #=> 10
 
-- since 3.2 for Array and Hash
-- since 3.5 for additional enumerable types
-- note requires `parser = future`.
+- since 4.0.0
 DOC
 ) do |args|
   function_fail(["reduce() is only available when parser/evaluator future is in effect"])
 end
diff --git a/lib/puppet/parser/functions/require.rb b/lib/puppet/parser/functions/require.rb
index d6350fc4b..6ce654bad 100644
--- a/lib/puppet/parser/functions/require.rb
+++ b/lib/puppet/parser/functions/require.rb
@@ -1,61 +1,63 @@
 # Requires the specified classes
 
   Puppet::Parser::Functions::newfunction(
     :require,
     :arity => -2,
     :doc =>"Evaluate one or more classes,  adding the required class as a dependency.
 
 The relationship metaparameters work well for specifying relationships
 between individual resources, but they can be clumsy for specifying
 relationships between classes.  This function is a superset of the
 'include' function, adding a class relationship so that the requiring
 class depends on the required class.
 
 Warning: using require in place of include can lead to unwanted dependency cycles.
 
 For instance the following manifest, with 'require' instead of 'include' would produce a nasty dependence cycle, because notify imposes a before between File[/foo] and Service[foo]:
 
     class myservice {
       service { foo: ensure => running }
     }
 
     class otherstuff {
       include myservice
       file { '/foo': notify => Service[foo] }
     }
 
 Note that this function only works with clients 0.25 and later, and it will
 fail if used with earlier clients.
 
-When the future parser is used, you must use the class's full name;
-relative names are no longer allowed. In addition to names in string form,
-you may also directly use Class and Resource Type values that are produced by
-the future parser's resource and relationship expressions.
+You must use the class's full name;
+relative names are not allowed. In addition to names in string form,
+you may also directly use Class and Resource Type values that are produced when evaluating
+resource and relationship expressions.
+
+- Since 4.0.0 Class and Resource types, absolute names
 ") do |vals|
   # Make call patterns uniform and protected against nested arrays, also make
   # names absolute if so desired.
   vals = transform_and_assert_classnames(vals.is_a?(Array) ? vals.flatten : [vals])
 
   # This is the same as calling the include function (but faster) since it again
   # would otherwise need to perform the optional absolute name transformation
   # (for no reason since they are already made absolute here).
   #
   compiler.evaluate_classes(vals, self, false)
 
   vals.each do |klass|
     # lookup the class in the scopes
     if classobj = find_hostclass(klass)
       klass = classobj.name
     else
       raise Puppet::ParseError, "Could not find class #{klass}"
     end
 
     # This is a bit hackish, in some ways, but it's the only way
     # to configure a dependency that will make it to the client.
     # The 'obvious' way is just to add an edge in the catalog,
     # but that is considered a containment edge, not a dependency
     # edge, so it usually gets lost on the client.
     ref = Puppet::Resource.new(:class, klass)
     resource.set_parameter(:require, [resource[:require]].flatten.compact << ref)
   end
 end
diff --git a/lib/puppet/parser/functions/scanf.rb b/lib/puppet/parser/functions/scanf.rb
index c9677c86b..b61c61285 100644
--- a/lib/puppet/parser/functions/scanf.rb
+++ b/lib/puppet/parser/functions/scanf.rb
@@ -1,35 +1,34 @@
 Puppet::Parser::Functions::newfunction(
   :scanf,
   :type => :rvalue,
   :arity => 2,
   :doc => <<-DOC
 Scans a string and returns an array of one or more converted values as directed by a given format string.args
 See the documenation of Ruby's String::scanf method for details about the supported formats (which
 are similar but not identical to the formats used in Puppet's `sprintf` function.
 
 This function takes two mandatory arguments: the first is the String to convert, and the second
 the format String. A parameterized block may optionally be given, which is called with the result
 that is produced by scanf if no block is present, the result of the block is then returned by
 the function.
 
 The result of the scan is an Array, with each sucessfully scanned and transformed value.args The scanning
 stops if a scan is unsuccesful and the scanned result up to that point is returned. If there was no
 succesful scan at all, the result is an empty Array. The optional code block is typically used to
 assert that the scan was succesful, and either produce the same input, or perform unwrapping of
 the result
 
 
       "42".scanf("%i")
       "42".scanf("%i") |$x| {
         unless $x[0] =~ Integer {
           fail "Expected a well formed integer value, got '$x[0]'"
         }
         $x[0]
       }
 
-- since 3.7.4
-- note requires `parser = future`
+- Since 4.0.0
 DOC
 ) do |args|
   function_fail(["scanf() is only available when parser/evaluator future is in effect"])
 end
diff --git a/lib/puppet/parser/functions/slice.rb b/lib/puppet/parser/functions/slice.rb
index d57b99cff..8bdb56ff8 100644
--- a/lib/puppet/parser/functions/slice.rb
+++ b/lib/puppet/parser/functions/slice.rb
@@ -1,48 +1,46 @@
 Puppet::Parser::Functions::newfunction(
   :slice,
   :type => :rvalue,
   :arity => -3,
   :doc => <<-DOC
 Applies a parameterized block to each _slice_ of elements in a sequence of selected entries from the first
 argument and returns the first argument, or if no block is given returns a new array with a concatenation of
 the slices.
 
 This function takes two mandatory arguments: the first, `$a`, should be an Array, Hash, or something of
 enumerable type (integer, Integer range, or String), and the second, `$n`, the number of elements to include
 in each slice. The optional third argument should be a a parameterized block as produced by the puppet syntax:
 
     $a.slice($n) |$x| { ... }
     slice($a) |$x| { ... }
 
 The parameterized block should have either one parameter (receiving an array with the slice), or the same number
 of parameters as specified by the slice size (each parameter receiving its part of the slice).
 In case there are fewer remaining elements than the slice size for the last slice it will contain the remaining
 elements. When the block has multiple parameters, excess parameters are set to undef for an array or
 enumerable type, and to empty arrays for a Hash.
 
     $a.slice(2) |$first, $second| { ... }
 
 When the first argument is a Hash, each `key,value` entry is counted as one, e.g, a slice size of 2 will produce
 an array of two arrays with key, and value.
 
 Example Using slice with Hash
 
     $a.slice(2) |$entry|          { notice "first ${$entry[0]}, second ${$entry[1]}" }
     $a.slice(2) |$first, $second| { notice "first ${first}, second ${second}" }
 
 When called without a block, the function produces a concatenated result of the slices.
 
 Example Using slice without a block
 
     slice([1,2,3,4,5,6], 2) # produces [[1,2], [3,4], [5,6]]
     slice(Integer[1,6], 2)  # produces [[1,2], [3,4], [5,6]]
     slice(4,2)              # produces [[0,1], [2,3]]
     slice('hello',2)        # produces [[h, e], [l, l], [o]]
 
-- since 3.2 for Array and Hash
-- since 3.5 for additional enumerable types
-- note requires `parser = future`.
+- Since 4.0.0
 DOC
 ) do |args|
   function_fail(["slice() is only available when parser/evaluator future is in effect"])
 end
diff --git a/lib/puppet/parser/functions/with.rb b/lib/puppet/parser/functions/with.rb
index 07beff6fd..806382a55 100644
--- a/lib/puppet/parser/functions/with.rb
+++ b/lib/puppet/parser/functions/with.rb
@@ -1,21 +1,20 @@
 Puppet::Parser::Functions::newfunction(
   :with,
   :type => :rvalue,
   :arity => -1,
   :doc => <<-DOC
 Call a lambda code block with the given arguments. Since the parameters of the lambda
 are local to the lambda's scope, this can be used to create private sections
 of logic in a class so that the variables are not visible outside of the
 class.
 
 Example:
 
      # notices the array [1, 2, 'foo']
      with(1, 2, 'foo') |$x, $y, $z| { notice [$x, $y, $z] }
 
-- since 3.7.0
-- note requires future parser
+- since 4.0.0
 DOC
 ) do |args|
   function_fail(["with() is only available when parser/evaluator future is in effect"])
 end
diff --git a/lib/puppet/resource/type.rb b/lib/puppet/resource/type.rb
index 4e0dffd46..e60fd1167 100644
--- a/lib/puppet/resource/type.rb
+++ b/lib/puppet/resource/type.rb
@@ -1,395 +1,395 @@
 require 'puppet/parser'
 require 'puppet/util/warnings'
 require 'puppet/util/errors'
 require 'puppet/parser/ast/leaf'
 
 # Puppet::Resource::Type represents nodes, classes and defined types.
 #
 # It has a standard format for external consumption, usable from the
 # resource_type indirection via rest and the resource_type face. See the
 # {file:api_docs/http_resource_type.md#Schema resource type schema
 # description}.
 #
 # @api public
 class Puppet::Resource::Type
   Puppet::ResourceType = self
   include Puppet::Util::Warnings
   include Puppet::Util::Errors
 
   RESOURCE_KINDS = [:hostclass, :node, :definition]
 
   # Map the names used in our documentation to the names used internally
   RESOURCE_KINDS_TO_EXTERNAL_NAMES = {
       :hostclass => "class",
       :node => "node",
       :definition => "defined_type",
   }
   RESOURCE_EXTERNAL_NAMES_TO_KINDS = RESOURCE_KINDS_TO_EXTERNAL_NAMES.invert
 
   attr_accessor :file, :line, :doc, :code, :parent, :resource_type_collection
   attr_reader :namespace, :arguments, :behaves_like, :module_name
 
   # Map from argument (aka parameter) names to Puppet Type
   # @return [Hash<Symbol, Puppet::Pops::Types::PAnyType] map from name to type
   #
   attr_reader :argument_types
 
   # This should probably be renamed to 'kind' eventually, in accordance with the changes
   #  made for serialization and API usability (#14137).  At the moment that seems like
   #  it would touch a whole lot of places in the code, though.  --cprice 2012-04-23
   attr_reader :type
 
   RESOURCE_KINDS.each do |t|
     define_method("#{t}?") { self.type == t }
   end
 
   require 'puppet/indirector'
   extend Puppet::Indirector
   indirects :resource_type, :terminus_class => :parser
 
   def self.from_data_hash(data)
     name = data.delete('name') or raise ArgumentError, "Resource Type names must be specified"
     kind = data.delete('kind') || "definition"
 
     unless type = RESOURCE_EXTERNAL_NAMES_TO_KINDS[kind]
       raise ArgumentError, "Unsupported resource kind '#{kind}'"
     end
 
     data = data.inject({}) { |result, ary| result[ary[0].intern] = ary[1]; result }
 
     # External documentation uses "parameters" but the internal name
     # is "arguments"
     data[:arguments] = data.delete(:parameters)
 
     new(type, name, data)
   end
 
   def to_data_hash
     data = [:doc, :line, :file, :parent].inject({}) do |hash, param|
       next hash unless (value = self.send(param)) and (value != "")
       hash[param.to_s] = value
       hash
     end
 
     # External documentation uses "parameters" but the internal name
     # is "arguments"
     data['parameters'] = arguments.dup unless arguments.empty?
 
     data['name'] = name
 
     unless RESOURCE_KINDS_TO_EXTERNAL_NAMES.has_key?(type)
       raise ArgumentError, "Unsupported resource kind '#{type}'"
     end
     data['kind'] = RESOURCE_KINDS_TO_EXTERNAL_NAMES[type]
     data
   end
 
   # Are we a child of the passed class?  Do a recursive search up our
   # parentage tree to figure it out.
   def child_of?(klass)
     return false unless parent
 
     return(klass == parent_type ? true : parent_type.child_of?(klass))
   end
 
   # Now evaluate the code associated with this class or definition.
   def evaluate_code(resource)
 
     static_parent = evaluate_parent_type(resource)
     scope = static_parent || resource.scope
 
     scope = scope.newscope(:namespace => namespace, :source => self, :resource => resource) unless resource.title == :main
     scope.compiler.add_class(name) unless definition?
 
     set_resource_parameters(resource, scope)
 
     resource.add_edge_to_stage
 
     if code
       if @match # Only bother setting up the ephemeral scope if there are match variables to add into it
         begin
           elevel = scope.ephemeral_level
           scope.ephemeral_from(@match, file, line)
           code.safeevaluate(scope)
         ensure
           scope.unset_ephemeral_var(elevel)
         end
       else
         code.safeevaluate(scope)
       end
     end
   end
 
   def initialize(type, name, options = {})
     @type = type.to_s.downcase.to_sym
     raise ArgumentError, "Invalid resource supertype '#{type}'" unless RESOURCE_KINDS.include?(@type)
 
     name = convert_from_ast(name) if name.is_a?(Puppet::Parser::AST::HostName)
 
     set_name_and_namespace(name)
 
     [:code, :doc, :line, :file, :parent].each do |param|
       next unless value = options[param]
       send(param.to_s + "=", value)
     end
 
     set_arguments(options[:arguments])
     set_argument_types(options[:argument_types])
 
     @match = nil
 
     @module_name = options[:module_name]
   end
 
   # This is only used for node names, and really only when the node name
   # is a regexp.
   def match(string)
     return string.to_s.downcase == name unless name_is_regex?
 
     @match = @name.match(string)
   end
 
   # Add code from a new instance to our code.
   def merge(other)
     fail "#{name} is not a class; cannot add code to it" unless type == :hostclass
     fail "#{other.name} is not a class; cannot add code from it" unless other.type == :hostclass
     fail "Cannot have code outside of a class/node/define because 'freeze_main' is enabled" if name == "" and Puppet.settings[:freeze_main]
 
     if parent and other.parent and parent != other.parent
       fail "Cannot merge classes with different parent classes (#{name} => #{parent} vs. #{other.name} => #{other.parent})"
     end
 
     # We know they're either equal or only one is set, so keep whichever parent is specified.
     self.parent ||= other.parent
 
     if other.doc
       self.doc ||= ""
       self.doc += other.doc
     end
 
     # This might just be an empty, stub class.
     return unless other.code
 
     unless self.code
       self.code = other.code
       return
     end
 
     self.code = Puppet::Parser::ParserFactory.code_merger.concatenate([self, other])
   end
 
   # Make an instance of the resource type, and place it in the catalog
   # if it isn't in the catalog already.  This is only possible for
   # classes and nodes.  No parameters are be supplied--if this is a
   # parameterized class, then all parameters take on their default
   # values.
   def ensure_in_catalog(scope, parameters=nil)
     type == :definition and raise ArgumentError, "Cannot create resources for defined resource types"
     resource_type = type == :hostclass ? :class : :node
 
     # Do nothing if the resource already exists; this makes sure we don't
     # get multiple copies of the class resource, which helps provide the
     # singleton nature of classes.
     # we should not do this for classes with parameters
     # if parameters are passed, we should still try to create the resource
     # even if it exists so that we can fail
     # this prevents us from being able to combine param classes with include
     if resource = scope.catalog.resource(resource_type, name) and !parameters
       return resource
     end
     resource = Puppet::Parser::Resource.new(resource_type, name, :scope => scope, :source => self)
     assign_parameter_values(parameters, resource)
     instantiate_resource(scope, resource)
     scope.compiler.add_resource(scope, resource)
     resource
   end
 
   def instantiate_resource(scope, resource)
     # Make sure our parent class has been evaluated, if we have one.
     if parent && !scope.catalog.resource(resource.type, parent)
       parent_type(scope).ensure_in_catalog(scope)
     end
 
     if ['Class', 'Node'].include? resource.type
       scope.catalog.tag(*resource.tags)
     end
   end
 
   def name
     return @name unless @name.is_a?(Regexp)
     @name.source.downcase.gsub(/[^-\w:.]/,'').sub(/^\.+/,'')
   end
 
   def name_is_regex?
     @name.is_a?(Regexp)
   end
 
   def assign_parameter_values(parameters, resource)
     return unless parameters
 
     # It'd be nice to assign default parameter values here,
     # but we can't because they often rely on local variables
     # created during set_resource_parameters.
     parameters.each do |name, value|
       resource.set_parameter name, value
     end
   end
 
   # MQR TODO:
   #
   # The change(s) introduced by the fix for #4270 are mostly silly & should be
   # removed, though we didn't realize it at the time.  If it can be established/
   # ensured that nodes never call parent_type and that resource_types are always
   # (as they should be) members of exactly one resource_type_collection the
   # following method could / should be replaced with:
   #
   # def parent_type
   #   @parent_type ||= parent && (
   #     resource_type_collection.find_or_load([name],parent,type.to_sym) ||
   #     fail Puppet::ParseError, "Could not find parent resource type '#{parent}' of type #{type} in #{resource_type_collection.environment}"
   #   )
   # end
   #
   # ...and then the rest of the changes around passing in scope reverted.
   #
   def parent_type(scope = nil)
     return nil unless parent
 
     unless @parent_type
       raise "Must pass scope to parent_type when called first time" unless scope
       unless @parent_type = scope.environment.known_resource_types.send("find_#{type}", [name], parent)
         fail Puppet::ParseError, "Could not find parent resource type '#{parent}' of type #{type} in #{scope.environment}"
       end
     end
 
     @parent_type
   end
 
   # Set any arguments passed by the resource as variables in the scope.
   def set_resource_parameters(resource, scope)
     set = {}
     resource.to_hash.each do |param, value|
       param = param.to_sym
       fail Puppet::ParseError, "#{resource.ref} does not accept attribute #{param}" unless valid_parameter?(param)
 
       exceptwrap { scope[param.to_s] = value }
 
       set[param] = true
     end
 
     if @type == :hostclass
       scope["title"] = resource.title.to_s.downcase unless set.include? :title
       scope["name"] =  resource.name.to_s.downcase  unless set.include? :name
     else
       scope["title"] = resource.title               unless set.include? :title
       scope["name"] =  resource.name                unless set.include? :name
     end
     scope["module_name"] = module_name if module_name and ! set.include? :module_name
 
     if caller_name = scope.parent_module_name and ! set.include?(:caller_module_name)
       scope["caller_module_name"] = caller_name
     end
     scope.class_set(self.name,scope) if hostclass? or node?
 
     # Evaluate the default parameters, now that all other variables are set
     default_params = resource.set_default_parameters(scope)
     default_params.each { |param| scope[param] = resource[param] }
 
     # This has to come after the above parameters so that default values
     # can use their values
     resource.validate_complete
   end
 
   # Check whether a given argument is valid.
   def valid_parameter?(param)
     param = param.to_s
 
     return true if param == "name"
     return true if Puppet::Type.metaparam?(param)
     return false unless defined?(@arguments)
     return(arguments.include?(param) ? true : false)
   end
 
   def set_arguments(arguments)
     @arguments = {}
     return if arguments.nil?
 
     arguments.each do |arg, default|
       arg = arg.to_s
       warn_if_metaparam(arg, default)
       @arguments[arg] = default
     end
   end
 
   # Sets the argument name to Puppet Type hash used for type checking.
   # Names must correspond to available arguments (they must be defined first).
-  # Arguments not mentioned will not be type-checked. Only supported when parser == "future"
+  # Arguments not mentioned will not be type-checked.
   #
   def set_argument_types(name_to_type_hash)
     @argument_types = {}
     return unless name_to_type_hash
     name_to_type_hash.each do |name, t|
       # catch internal errors
       unless @arguments.include?(name)
         raise Puppet::DevError, "Parameter '#{name}' is given a type, but is not a valid parameter."
       end
       unless t.is_a? Puppet::Pops::Types::PAnyType
         raise Puppet::DevError, "Parameter '#{name}' is given a type that is not a Puppet Type, got #{t.class}"
       end
       @argument_types[name] = t
     end
   end
 
   private
 
   def convert_from_ast(name)
     value = name.value
     if value.is_a?(Puppet::Parser::AST::Regex)
       name = value.value
     else
       name = value
     end
   end
 
   def evaluate_parent_type(resource)
     return unless klass = parent_type(resource.scope) and parent_resource = resource.scope.compiler.catalog.resource(:class, klass.name) || resource.scope.compiler.catalog.resource(:node, klass.name)
     parent_resource.evaluate unless parent_resource.evaluated?
     parent_scope(resource.scope, klass)
   end
 
   # Split an fq name into a namespace and name
   def namesplit(fullname)
     ary = fullname.split("::")
     n = ary.pop || ""
     ns = ary.join("::")
     return ns, n
   end
 
   def parent_scope(scope, klass)
     scope.class_scope(klass) || raise(Puppet::DevError, "Could not find scope for #{klass.name}")
   end
 
   def set_name_and_namespace(name)
     if name.is_a?(Regexp)
       @name = name
       @namespace = ""
     else
       @name = name.to_s.downcase
 
       # Note we're doing something somewhat weird here -- we're setting
       # the class's namespace to its fully qualified name.  This means
       # anything inside that class starts looking in that namespace first.
       @namespace, ignored_shortname = @type == :hostclass ? [@name, ''] : namesplit(@name)
     end
   end
 
   def warn_if_metaparam(param, default)
     return unless Puppet::Type.metaparamclass(param)
 
     if default
       warnonce "#{param} is a metaparam; this value will inherit to all contained resources in the #{self.name} definition"
     else
       raise Puppet::ParseError, "#{param} is a metaparameter; please choose another parameter name in the #{self.name} definition"
     end
   end
 end
diff --git a/spec/integration/parser/compiler4_spec.rb b/spec/integration/parser/compiler4_spec.rb
index e1944b8c1..7b4da353d 100644
--- a/spec/integration/parser/compiler4_spec.rb
+++ b/spec/integration/parser/compiler4_spec.rb
@@ -1,770 +1,770 @@
 require 'spec_helper'
 require 'puppet/pops'
 require 'puppet/parser/parser_factory'
 require 'puppet_spec/compiler'
 require 'puppet_spec/pops'
 require 'puppet_spec/scope'
 require 'matchers/resource'
 require 'rgen/metamodel_builder'
 
 describe "Puppet::Parser::Compiler" do
   include PuppetSpec::Compiler
   include Matchers::Resource
 
-  describe "the compiler when using future parser and evaluator" do
+  describe "the compiler" do
     it "should be able to determine the configuration version from a local version control repository" do
       pending("Bug #14071 about semantics of Puppet::Util::Execute on Windows", :if => Puppet.features.microsoft_windows?) do
         # This should always work, because we should always be
         # in the puppet repo when we run this.
         version = %x{git rev-parse HEAD}.chomp
 
         Puppet.settings[:config_version] = 'git rev-parse HEAD'
 
         compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("testnode"))
         compiler.catalog.version.should == version
       end
     end
 
     it "should not create duplicate resources when a class is referenced both directly and indirectly by the node classifier (4792)" do
       node = Puppet::Node.new("testnodex")
       node.classes = ['foo', 'bar']
       catalog = compile_to_catalog(<<-PP, node)
         class foo
         {
           notify { foo_notify: }
           include bar
         }
         class bar
         {
           notify { bar_notify: }
         }
       PP
 
       catalog = Puppet::Parser::Compiler.compile(node)
 
       expect(catalog).to have_resource("Notify[foo_notify]")
       expect(catalog).to have_resource("Notify[bar_notify]")
     end
 
     it 'applies defaults for defines with qualified names (PUP-2302)' do
       catalog = compile_to_catalog(<<-CODE)
         define my::thing($msg = 'foo') { notify {'check_me': message => $msg } }
         My::Thing { msg => 'evoe' }
         my::thing { 'name': }
       CODE
 
       expect(catalog).to have_resource("Notify[check_me]").with_parameter(:message, "evoe")
     end
 
-    it 'Applies defaults from dynamic scopes (3x and future with reverted PUP-867)' do
+    it 'Applies defaults from dynamic scopes (3x and 4x with reverted PUP-867)' do
       catalog = compile_to_catalog(<<-CODE)
       class a {
         Notify { message => "defaulted" }
         include b
         notify { bye: }
       }
       class b { notify { hi: } }
 
       include a
       CODE
       expect(catalog).to have_resource("Notify[hi]").with_parameter(:message, "defaulted")
       expect(catalog).to have_resource("Notify[bye]").with_parameter(:message, "defaulted")
     end
 
     it 'gets default from inherited class (PUP-867)' do
       catalog = compile_to_catalog(<<-CODE)
       class a {
         Notify { message => "defaulted" }
         include c
         notify { bye: }
       }
       class b { Notify { message => "inherited" } }
       class c inherits b { notify { hi: } }
 
       include a
       CODE
 
       expect(catalog).to have_resource("Notify[hi]").with_parameter(:message, "inherited")
       expect(catalog).to have_resource("Notify[bye]").with_parameter(:message, "defaulted")
     end
 
     it 'looks up default parameter values from inherited class (PUP-2532)' do
       catalog = compile_to_catalog(<<-CODE)
       class a {
         Notify { message => "defaulted" }
         include c
         notify { bye: }
       }
       class b { Notify { message => "inherited" } }
       class c inherits b { notify { hi: } }
 
       include a
       notify {hi_test: message => Notify[hi][message] }
       notify {bye_test: message => Notify[bye][message] }
       CODE
 
       expect(catalog).to have_resource("Notify[hi_test]").with_parameter(:message, "inherited")
       expect(catalog).to have_resource("Notify[bye_test]").with_parameter(:message, "defaulted")
     end
 
     it 'does not allow override of class parameters using a resource override expression' do
       expect do
         compile_to_catalog(<<-CODE)
           Class[a] { x => 2}
         CODE
       end.to raise_error(/Resource Override can only.*got: Class\[a\].*/)
     end
 
     describe "when resolving class references" do
       it "should not favor local scope (with class included in topscope)" do
         catalog = compile_to_catalog(<<-PP)
           class experiment {
             class baz {
             }
             notify {"x" : require => Class[Baz] }
             notify {"y" : require => Class[Experiment::Baz] }
           }
           class baz {
           }
           include baz
           include experiment
           include experiment::baz
         PP
 
         expect(catalog).to have_resource("Notify[x]").with_parameter(:require, be_resource("Class[Baz]"))
         expect(catalog).to have_resource("Notify[y]").with_parameter(:require, be_resource("Class[Experiment::Baz]"))
       end
 
       it "should not favor local scope, (with class not included in topscope)" do
         catalog = compile_to_catalog(<<-PP)
           class experiment {
             class baz {
             }
             notify {"x" : require => Class[Baz] }
             notify {"y" : require => Class[Experiment::Baz] }
           }
           class baz {
           }
           include experiment
           include experiment::baz
         PP
 
         expect(catalog).to have_resource("Notify[x]").with_parameter(:require, be_resource("Class[Baz]"))
         expect(catalog).to have_resource("Notify[y]").with_parameter(:require, be_resource("Class[Experiment::Baz]"))
       end
     end
 
     describe "(ticket #13349) when explicitly specifying top scope" do
       ["class {'::bar::baz':}", "include ::bar::baz"].each do |include|
         describe "with #{include}" do
           it "should find the top level class" do
             catalog = compile_to_catalog(<<-MANIFEST)
               class { 'foo::test': }
               class foo::test {
               	#{include}
               }
               class bar::baz {
               	notify { 'good!': }
               }
               class foo::bar::baz {
               	notify { 'bad!': }
               }
             MANIFEST
 
             expect(catalog).to have_resource("Class[Bar::Baz]")
             expect(catalog).to have_resource("Notify[good!]")
             expect(catalog).to_not have_resource("Class[Foo::Bar::Baz]")
             expect(catalog).to_not have_resource("Notify[bad!]")
           end
         end
       end
     end
 
     it "should recompute the version after input files are re-parsed" do
       Puppet[:code] = 'class foo { }'
       Time.stubs(:now).returns(1)
       node = Puppet::Node.new('mynode')
       Puppet::Parser::Compiler.compile(node).version.should == 1
       Time.stubs(:now).returns(2)
       Puppet::Parser::Compiler.compile(node).version.should == 1 # no change because files didn't change
       Puppet::Resource::TypeCollection.any_instance.stubs(:stale?).returns(true).then.returns(false) # pretend change
       Puppet::Parser::Compiler.compile(node).version.should == 2
     end
 
     ['define', 'class', 'node'].each do |thing|
       it "'#{thing}' is not allowed inside evaluated conditional constructs" do
         expect do
           compile_to_catalog(<<-PP)
             if true {
               #{thing} foo {
               }
               notify { decoy: }
             }
           PP
         end.to raise_error(Puppet::Error, /Classes, definitions, and nodes may only appear at toplevel/)
       end
 
       it "'#{thing}' is not allowed inside un-evaluated conditional constructs" do
         expect do
           compile_to_catalog(<<-PP)
             if false {
               #{thing} foo {
               }
               notify { decoy: }
             }
           PP
         end.to raise_error(Puppet::Error, /Classes, definitions, and nodes may only appear at toplevel/)
       end
     end
 
     describe "relationships can be formed" do
       def extract_name(ref)
         ref.sub(/File\[(\w+)\]/, '\1')
       end
 
       def assert_creates_relationships(relationship_code, expectations)
         base_manifest = <<-MANIFEST
           file { [a,b,c]:
             mode => '0644',
           }
           file { [d,e]:
             mode => '0755',
           }
         MANIFEST
         catalog = compile_to_catalog(base_manifest + relationship_code)
 
         resources = catalog.resources.select { |res| res.type == 'File' }
 
         actual_relationships, actual_subscriptions = [:before, :notify].map do |relation|
           resources.map do |res|
             dependents = Array(res[relation])
             dependents.map { |ref| [res.title, extract_name(ref)] }
           end.inject(&:concat)
         end
 
         actual_relationships.should =~ (expectations[:relationships] || [])
         actual_subscriptions.should =~ (expectations[:subscriptions] || [])
       end
 
       it "of regular type" do
         assert_creates_relationships("File[a] -> File[b]",
                                      :relationships => [['a','b']])
       end
 
       it "of subscription type" do
         assert_creates_relationships("File[a] ~> File[b]",
                                      :subscriptions => [['a', 'b']])
       end
 
       it "between multiple resources expressed as resource with multiple titles" do
         assert_creates_relationships("File[a,b] -> File[c,d]",
                                      :relationships => [['a', 'c'],
                                                         ['b', 'c'],
                                                         ['a', 'd'],
                                                         ['b', 'd']])
       end
 
       it "between collection expressions" do
         assert_creates_relationships("File <| mode == '0644' |> -> File <| mode == '0755' |>",
                                      :relationships => [['a', 'd'],
                                                         ['b', 'd'],
                                                         ['c', 'd'],
                                                         ['a', 'e'],
                                                         ['b', 'e'],
                                                         ['c', 'e']])
       end
 
       it "between resources expressed as Strings" do
         assert_creates_relationships("'File[a]' -> 'File[b]'",
                                      :relationships => [['a', 'b']])
       end
 
       it "between resources expressed as variables" do
         assert_creates_relationships(<<-MANIFEST, :relationships => [['a', 'b']])
           $var = File[a]
           $var -> File[b]
         MANIFEST
 
       end
 
       it "between resources expressed as case statements" do
         assert_creates_relationships(<<-MANIFEST, :relationships => [['s1', 't2']])
           $var = 10
           case $var {
             10: {
               file { s1: }
             }
             12: {
               file { s2: }
             }
           }
           ->
           case $var + 2 {
             10: {
               file { t1: }
             }
             12: {
               file { t2: }
             }
           }
         MANIFEST
       end
 
       it "using deep access in array" do
         assert_creates_relationships(<<-MANIFEST, :relationships => [['a', 'b']])
           $var = [ [ [ File[a], File[b] ] ] ]
           $var[0][0][0] -> $var[0][0][1]
         MANIFEST
 
       end
 
       it "using deep access in hash" do
         assert_creates_relationships(<<-MANIFEST, :relationships => [['a', 'b']])
           $var = {'foo' => {'bar' => {'source' => File[a], 'target' => File[b]}}}
           $var[foo][bar][source] -> $var[foo][bar][target]
         MANIFEST
 
       end
 
       it "using resource declarations" do
         assert_creates_relationships("file { l: } -> file { r: }", :relationships => [['l', 'r']])
       end
 
       it "between entries in a chain of relationships" do
         assert_creates_relationships("File[a] -> File[b] ~> File[c] <- File[d] <~ File[e]",
                                      :relationships => [['a', 'b'], ['d', 'c']],
                                      :subscriptions => [['b', 'c'], ['e', 'd']])
       end
     end
 
     context "when dealing with variable references" do
       it 'an initial underscore in a variable name is ok' do
         catalog = compile_to_catalog(<<-MANIFEST)
           class a { $_a = 10}
           include a
           notify { 'test': message => $a::_a }
         MANIFEST
 
         expect(catalog).to have_resource("Notify[test]").with_parameter(:message, 10)
       end
 
       it 'an initial underscore in not ok if elsewhere than last segment' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
             class a { $_a = 10}
             include a
             notify { 'test': message => $_a::_a }
           MANIFEST
         end.to raise_error(/Illegal variable name/)
       end
 
       it 'a missing variable as default value becomes undef' do
         # strict variables not on
         catalog = compile_to_catalog(<<-MANIFEST)
         class a ($b=$x) { notify {test: message=>"yes ${undef == $b}" } }
           include a
         MANIFEST
 
         expect(catalog).to have_resource("Notify[test]").with_parameter(:message, "yes true")
       end
     end
 
     context 'when working with the trusted data hash' do
 
       it 'should make $trusted available' do
         node = Puppet::Node.new("testing")
         node.trusted_data = { "data" => "value" }
 
         catalog = compile_to_catalog(<<-MANIFEST, node)
           notify { 'test': message => $trusted[data] }
         MANIFEST
 
         expect(catalog).to have_resource("Notify[test]").with_parameter(:message, "value")
       end
 
       it 'should not allow assignment to $trusted' do
         node = Puppet::Node.new("testing")
         node.trusted_data = { "data" => "value" }
 
         expect do
           compile_to_catalog(<<-MANIFEST, node)
             $trusted = 'changed'
             notify { 'test': message => $trusted == 'changed' }
           MANIFEST
         end.to raise_error(Puppet::Error, /Attempt to assign to a reserved variable name: 'trusted'/)
       end
     end
 
     context 'when using typed parameters in definition' do
       it 'accepts type compliant arguments' do
         catalog = compile_to_catalog(<<-MANIFEST)
           define foo(String $x) { }
           foo { 'test': x =>'say friend' }
         MANIFEST
         expect(catalog).to have_resource("Foo[test]").with_parameter(:x, 'say friend')
       end
 
       it 'accepts undef as the default for an Optional argument' do
         catalog = compile_to_catalog(<<-MANIFEST)
           define foo(Optional[String] $x = undef) {
             notify { "expected": message => $x == undef }
           }
           foo { 'test': }
         MANIFEST
         expect(catalog).to have_resource("Notify[expected]").with_parameter(:message, true)
       end
 
       it 'accepts anything when parameters are untyped' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
           define foo($a, $b, $c) { }
           foo { 'test': a => String, b=>10, c=>undef }
         MANIFEST
         end.to_not raise_error()
       end
 
       it 'denies non type compliant arguments' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
             define foo(Integer $x) { }
             foo { 'test': x =>'say friend' }
           MANIFEST
         end.to raise_error(/type Integer, got String/)
       end
 
       it 'denies undef for a non-optional type' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
             define foo(Integer $x) { }
             foo { 'test': x => undef }
           MANIFEST
         end.to raise_error(/type Integer, got Undef/)
       end
 
       it 'denies non type compliant default argument' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
             define foo(Integer $x = 'pow') { }
             foo { 'test':  }
           MANIFEST
         end.to raise_error(/type Integer, got String/)
       end
 
       it 'denies undef as the default for a non-optional type' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
             define foo(Integer $x = undef) { }
             foo { 'test':  }
           MANIFEST
         end.to raise_error(/type Integer, got Undef/)
       end
 
       it 'accepts a Resource as a Type' do
         catalog = compile_to_catalog(<<-MANIFEST)
           define foo(Type[Bar] $x) {
             notify { 'test': message => $x[text] }
           }
           define bar($text) { }
           bar { 'joke': text => 'knock knock' }
           foo { 'test': x => Bar[joke] }
         MANIFEST
         expect(catalog).to have_resource("Notify[test]").with_parameter(:message, 'knock knock')
       end
     end
 
     context 'when using typed parameters in class' do
       it 'accepts type compliant arguments' do
         catalog = compile_to_catalog(<<-MANIFEST)
           class foo(String $x) { }
           class { 'foo': x =>'say friend' }
         MANIFEST
         expect(catalog).to have_resource("Class[Foo]").with_parameter(:x, 'say friend')
       end
 
       it 'accepts undef as the default for an Optional argument' do
         catalog = compile_to_catalog(<<-MANIFEST)
           class foo(Optional[String] $x = undef) {
             notify { "expected": message => $x == undef }
           }
           class { 'foo': }
         MANIFEST
         expect(catalog).to have_resource("Notify[expected]").with_parameter(:message, true)
       end
 
       it 'accepts anything when parameters are untyped' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
             class foo($a, $b, $c) { }
             class { 'foo': a => String, b=>10, c=>undef }
           MANIFEST
         end.to_not raise_error()
       end
 
       it 'denies non type compliant arguments' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
             class foo(Integer $x) { }
             class { 'foo': x =>'say friend' }
           MANIFEST
         end.to raise_error(/type Integer, got String/)
       end
 
       it 'denies undef for a non-optional type' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
             class foo(Integer $x) { }
             class { 'foo': x => undef }
           MANIFEST
         end.to raise_error(/type Integer, got Undef/)
       end
 
       it 'denies non type compliant default argument' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
             class foo(Integer $x = 'pow') { }
             class { 'foo':  }
           MANIFEST
         end.to raise_error(/type Integer, got String/)
       end
 
       it 'denies undef as the default for a non-optional type' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
             class foo(Integer $x = undef) { }
             class { 'foo':  }
           MANIFEST
         end.to raise_error(/type Integer, got Undef/)
       end
 
       it 'accepts a Resource as a Type' do
         catalog = compile_to_catalog(<<-MANIFEST)
           class foo(Type[Bar] $x) {
             notify { 'test': message => $x[text] }
           }
           define bar($text) { }
           bar { 'joke': text => 'knock knock' }
           class { 'foo': x => Bar[joke] }
         MANIFEST
         expect(catalog).to have_resource("Notify[test]").with_parameter(:message, 'knock knock')
       end
     end
 
     context 'when using typed parameters in lambdas' do
       it 'accepts type compliant arguments' do
         catalog = compile_to_catalog(<<-MANIFEST)
           with('value') |String $x| { notify { "$x": } }
         MANIFEST
         expect(catalog).to have_resource("Notify[value]")
       end
 
       it 'handles an array as a single argument' do
         catalog = compile_to_catalog(<<-MANIFEST)
           with(['value', 'second']) |$x| { notify { "${x[0]} ${x[1]}": } }
         MANIFEST
         expect(catalog).to have_resource("Notify[value second]")
       end
 
       it 'denies when missing required arguments' do
         expect do
           compile_to_catalog(<<-MANIFEST)
             with(1) |$x, $y| { }
           MANIFEST
         end.to raise_error(/Parameter \$y is required but no value was given/m)
       end
 
       it 'accepts anything when parameters are untyped' do
         catalog = compile_to_catalog(<<-MANIFEST)
           ['value', 1, true, undef].each |$x| { notify { "value: $x": } }
         MANIFEST
 
         expect(catalog).to have_resource("Notify[value: value]")
         expect(catalog).to have_resource("Notify[value: 1]")
         expect(catalog).to have_resource("Notify[value: true]")
         expect(catalog).to have_resource("Notify[value: ]")
       end
 
       it 'accepts type-compliant, slurped arguments' do
         catalog = compile_to_catalog(<<-MANIFEST)
           with(1, 2) |Integer *$x| { notify { "${$x[0] + $x[1]}": } }
         MANIFEST
         expect(catalog).to have_resource("Notify[3]")
       end
 
       it 'denies non-type-compliant arguments' do
         expect do
           compile_to_catalog(<<-MANIFEST)
             with(1) |String $x| { }
           MANIFEST
         end.to raise_error(/expected.*String.*actual.*Integer/m)
       end
 
       it 'denies non-type-compliant, slurped arguments' do
         expect do
           compile_to_catalog(<<-MANIFEST)
             with(1, "hello") |Integer *$x| { }
           MANIFEST
         end.to raise_error(/called with mis-matched arguments.*expected.*Integer.*actual.*Integer, String/m)
       end
 
       it 'denies non-type-compliant default argument' do
         expect do
           compile_to_catalog(<<-MANIFEST)
             with(1) |$x, String $defaulted = 1| { notify { "${$x + $defaulted}": }}
           MANIFEST
         end.to raise_error(/expected.*Any.*String.*actual.*Integer.*Integer/m)
       end
 
       it 'raises an error when a default argument value is an incorrect type and there are no arguments passed' do
         expect do
           compile_to_catalog(<<-MANIFEST)
             with() |String $defaulted = 1| {}
           MANIFEST
         end.to raise_error(/expected.*String.*actual.*Integer/m)
       end
 
       it 'raises an error when the default argument for a slurped parameter is an incorrect type' do
         expect do
           compile_to_catalog(<<-MANIFEST)
             with() |String *$defaulted = 1| {}
           MANIFEST
         end.to raise_error(/expected.*String.*actual.*Integer/m)
       end
 
       it 'allows using an array as the default slurped value' do
         catalog = compile_to_catalog(<<-MANIFEST)
           with() |String *$defaulted = [hi]| { notify { $defaulted[0]: } }
         MANIFEST
 
         expect(catalog).to have_resource('Notify[hi]')
       end
 
       it 'allows using a value of the type as the default slurped value' do
         catalog = compile_to_catalog(<<-MANIFEST)
           with() |String *$defaulted = hi| { notify { $defaulted[0]: } }
         MANIFEST
 
         expect(catalog).to have_resource('Notify[hi]')
       end
 
       it 'allows specifying the type of a slurped parameter as an array' do
         catalog = compile_to_catalog(<<-MANIFEST)
           with() |Array[String] *$defaulted = hi| { notify { $defaulted[0]: } }
         MANIFEST
 
         expect(catalog).to have_resource('Notify[hi]')
       end
 
       it 'raises an error when the number of default values does not match the parameter\'s size specification' do
         expect do
           compile_to_catalog(<<-MANIFEST)
             with() |Array[String, 2] *$defaulted = hi| { }
           MANIFEST
         end.to raise_error(/expected.*arg count \{2,\}.*actual.*arg count \{1\}/m)
       end
 
       it 'raises an error when the number of passed values does not match the parameter\'s size specification' do
         expect do
           compile_to_catalog(<<-MANIFEST)
             with(hi) |Array[String, 2] *$passed| { }
           MANIFEST
         end.to raise_error(/expected.*arg count \{2,\}.*actual.*arg count \{1\}/m)
       end
 
       it 'matches when the number of arguments passed for a slurp parameter match the size specification' do
         catalog = compile_to_catalog(<<-MANIFEST)
           with(hi, bye) |Array[String, 2] *$passed| {
             $passed.each |$n| { notify { $n: } }
           }
         MANIFEST
 
         expect(catalog).to have_resource('Notify[hi]')
         expect(catalog).to have_resource('Notify[bye]')
       end
 
       it 'raises an error when the number of allowed slurp parameters exceeds the size constraint' do
         expect do
           compile_to_catalog(<<-MANIFEST)
             with(hi, bye) |Array[String, 1, 1] *$passed| { }
           MANIFEST
         end.to raise_error(/expected.*arg count \{1\}.*actual.*arg count \{2\}/m)
       end
 
       it 'allows passing slurped arrays by specifying an array of arrays' do
         catalog = compile_to_catalog(<<-MANIFEST)
           with([hi], [bye]) |Array[Array[String, 1, 1]] *$passed| {
             notify { $passed[0][0]: }
             notify { $passed[1][0]: }
           }
         MANIFEST
 
         expect(catalog).to have_resource('Notify[hi]')
         expect(catalog).to have_resource('Notify[bye]')
       end
 
       it 'raises an error when a required argument follows an optional one' do
         expect do
           compile_to_catalog(<<-MANIFEST)
             with() |$y = first, $x, Array[String, 1] *$passed = bye| {}
           MANIFEST
         end.to raise_error(/Parameter \$x is required/)
       end
 
       it 'raises an error when the minimum size of a slurped argument makes it required and it follows an optional argument' do
         expect do
           compile_to_catalog(<<-MANIFEST)
             with() |$x = first, Array[String, 1] *$passed| {}
           MANIFEST
         end.to raise_error(/Parameter \$passed is required/)
       end
 
       it 'allows slurped arguments with a minimum size of 0 after an optional argument' do
         catalog = compile_to_catalog(<<-MANIFEST)
           with() |$x = first, Array[String, 0] *$passed| {
             notify { $x: }
           }
         MANIFEST
 
         expect(catalog).to have_resource('Notify[first]')
       end
 
       it 'accepts a Resource as a Type' do
         catalog = compile_to_catalog(<<-MANIFEST)
           define bar($text) { }
           bar { 'joke': text => 'knock knock' }
 
           with(Bar[joke]) |Type[Bar] $joke| { notify { "${joke[text]}": } }
         MANIFEST
         expect(catalog).to have_resource("Notify[knock knock]")
       end
     end
   end
 
   context 'when evaluating collection' do
     it 'matches on container inherited tags' do
       Puppet[:code] = <<-MANIFEST
       class xport_test {
         tag('foo_bar')
         @notify { 'nbr1':
           message => 'explicitly tagged',
           tag => 'foo_bar'
         }
 
         @notify { 'nbr2':
           message => 'implicitly tagged'
         }
 
         Notify <| tag == 'foo_bar' |> {
           message => 'overridden'
         }
       }
       include xport_test
       MANIFEST
 
       catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
 
       expect(catalog).to have_resource("Notify[nbr1]").with_parameter(:message, 'overridden')
       expect(catalog).to have_resource("Notify[nbr2]").with_parameter(:message, 'overridden')
     end
   end
 
 end
diff --git a/spec/unit/parser/functions/defined_spec.rb b/spec/unit/parser/functions/defined_spec.rb
index 91590254f..201110890 100755
--- a/spec/unit/parser/functions/defined_spec.rb
+++ b/spec/unit/parser/functions/defined_spec.rb
@@ -1,106 +1,106 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/pops'
 
 describe "the 'defined' function" do
 
   before :each do
     @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))
     @scope = Puppet::Parser::Scope.new(@compiler)
   end
 
   it "exists" do
     expect(Puppet::Parser::Functions.function("defined")).to be_eql("function_defined")
   end
 
   it "is true when the name is defined as a class" do
     @scope.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "yayness")
     expect(@scope.function_defined(["yayness"])).to be_true
   end
 
   it "is true when the name is defined as a definition" do
     @scope.known_resource_types.add Puppet::Resource::Type.new(:definition, "yayness")
     expect(@scope.function_defined(["yayness"])).to be_true
   end
 
   it "is true when the name is defined as a builtin type" do
     expect(@scope.function_defined(["file"])).to be_true
   end
 
   it "is true when any of the provided names are defined" do
     @scope.known_resource_types.add Puppet::Resource::Type.new(:definition, "yayness")
     expect(@scope.function_defined(["meh", "yayness", "booness"])).to be_true
   end
 
   it "is false when a single given name is not defined" do
     expect(@scope.function_defined(["meh"])).to be_false
   end
 
   it "is false when none of the names are defined" do
     expect(@scope.function_defined(["meh", "yayness", "booness"])).to be_false
   end
 
   it "is true when a resource reference is provided and the resource is in the catalog" do
     resource = Puppet::Resource.new("file", "/my/file")
     @compiler.add_resource(@scope, resource)
     expect(@scope.function_defined([resource])).to be_true
   end
 
   context "with string variable references" do
     it "is true when variable exists in scope" do
       @scope['x'] = 'something'
       expect(@scope.function_defined(['$x'])).to be_true
     end
 
     it "is true when at least one variable exists in scope" do
       @scope['x'] = 'something'
       expect(@scope.function_defined(['$y', '$x', '$z'])).to be_true
     end
 
     it "is false when variable does not exist in scope" do
       expect(@scope.function_defined(['$x'])).to be_false
     end
   end
 
-  it "is true when a future resource type reference is provided, and the resource is in the catalog" do
+  it "is true when a resource type reference is provided, and the resource is in the catalog" do
     resource = Puppet::Resource.new("file", "/my/file")
     @compiler.add_resource(@scope, resource)
 
     resource_type = Puppet::Pops::Types::TypeFactory.resource('file', '/my/file')
     expect(@scope.function_defined([resource_type])).to be_true
   end
 
   it "raises an argument error if you ask if Resource is defined" do
     resource_type = Puppet::Pops::Types::TypeFactory.resource
     expect { @scope.function_defined([resource_type]) }.to raise_error(ArgumentError, /reference to all.*type/)
   end
 
   it "is true if referencing a built in type" do
     resource_type = Puppet::Pops::Types::TypeFactory.resource('file')
     expect(@scope.function_defined([resource_type])).to be_true
   end
 
   it "is true if referencing a defined type" do
     @scope.known_resource_types.add Puppet::Resource::Type.new(:definition, "yayness")
     resource_type = Puppet::Pops::Types::TypeFactory.resource('yayness')
     expect(@scope.function_defined([resource_type])).to be_true
   end
 
   it "is false if referencing an undefined type" do
     resource_type = Puppet::Pops::Types::TypeFactory.resource('barbershops')
     expect(@scope.function_defined([resource_type])).to be_false
   end
 
-  it "is true when a future class reference type is provided" do
+  it "is true when a class type is provided" do
     @scope.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "cowabunga")
 
     class_type = Puppet::Pops::Types::TypeFactory.host_class("cowabunga")
     expect(@scope.function_defined([class_type])).to be_true
   end
 
   it "raises an argument error if you ask if Class is defined" do
     class_type = Puppet::Pops::Types::TypeFactory.host_class
     expect { @scope.function_defined([class_type]) }.to raise_error(ArgumentError, /reference to all.*class/)
   end
 
 end