if (stringFormatter != null) {
            return stringFormatter.toString(location);
        }
        if (location.getSource() != null) {
            return ' ' + location.getSource().toString() + ':' + location.getLineNumber() + ' ';
        } else {
            return " " + location.getLineNumber() + " ";
        }
    } //-- String toString(InputLocation)
#end

        override fun getContributedVariables(name: Name, location: LookupLocation): Collection<PropertyDescriptor> {
            return allMemberScope.getContributedVariables(name, location).filter {
                it.isDeclaredInOwner() && it.isDelegatedIfRequired()
            }.mapToDelegatedIfRequired()
        }

        override fun getContributedFunctions(name: Name, location: LookupLocation): Collection<SimpleFunctionDescriptor> {

        @Nonnull
        public Builder location(Object key, InputLocation location) {
            if (location != null) {
                if (!(this.locations instanceof HashMap)) {
                    this.locations = this.locations != null ? new HashMap<>(this.locations) : new HashMap<>();
                }
                this.locations.put(key, location);
            }
            return this;
        }

            builder.${field.name}(merged);
        #if ( $locationTracking )
            if (target.get${capField}() == null) {
                builder.location("${field.name}", source.getLocation("${field.name}"));
            } else if (merged != tgt) {
                builder.location("${field.name}", new InputLocation(-1, -1));
            }
        #end
        }
      #elseif ( $field.to && $field.multiplicity == "*" )

        return loc != null ? new InputLocation(loc) : null;
    }

    public void setLocation(Object key, InputLocation location) {
        update(${packageModelV4}.${class.name}.newBuilder(getDelegate(), true)
                        .location(key, location.toApiLocation()).build());
    }

    #end
    protected boolean replace(Object oldDelegate, Object newDelegate) {

* Implications for Subsystems

** Maven-Wagon

  Parts of Wagon will continue to function normally. These include:

  * The file wagon, provided the referenced location is on a local
    filesystem.

    It is not possible to determine whether a file-based location will
    be available except on a case-by-case basis (or a root-url by
    root-url basis). We may want to move the offline sensitivity entirely to

#if ( $locationTracking )
    /**
     * Returns the state of the "add location information" flag.
     *
     * @return boolean
     */
    public boolean getAddLocationInformation() {
        return addLocationInformation;
    } //-- boolean getAddLocationInformation()

    /**
     * Sets the state of the "add location information" flag.
     *

  is not sufficient to license the Source Code under Secondary Licenses.

  If it is not possible or desirable to put the notice in a particular
  file, then You may include the notice in a location (such as a LICENSE
  file in a relevant directory) where a recipient would be likely to
  look for such a notice.

* installation
* activation
* update
* deactivation
* un-installation

When a plugin is installed we may want to check the license and make users agree. We may also want to unpack the given plugin in a particular location.

    /**
     * The name of the value parameter. For a parameter of `FunctionN.invoke()` functions, the name is taken from the function type
     * notation, if a name is present. For example:
     * ```
     * fun foo(x: (item: Int, String) -> Unit) =
     *   x(1, "") // or `x.invoke(1, "")`
     * ```