val result = SmartList<KotlinPsiReferenceProvider>()
            for (bindingClass in originalProvidersBinding.keySet()) {
                if (bindingClass.isAssignableFrom(klass)) {
                    result.addAll(originalProvidersBinding.get(bindingClass))
                }
            }
            result
        }
    }

    private fun doGetKotlinReferencesFromProviders(context: PsiElement): Array<PsiReference> {

     */
    public String getType() {
        return type;
    }

    @Override
    public List<String> getResolutions() {
        return ImmutableList.<String>builder()
            .addAll(resolutions)
            .addAll(super.getResolutions()) // Calculated from causes
            .build();
    }

    private static String buildMessage(String type, String displayName) {

    EnumMultiset<E> multiset = new EnumMultiset<>(map);
    Iterables.addAll(multiset, elements);
    return multiset;
  }

  public static <E extends Enum<E>> EnumMultiset<E> create(Iterable<E> elements, Class<E> type) {
    EnumMultiset<E> result = create(type);
    Iterables.addAll(result, elements);
    return result;
  }

  /** Creates an empty {@code EnumMultiset}. */

        model.authors.addAll(descriptor.getAuthors());
        model.licenses.addAll(descriptor.getLicenses());
        model.configurations.addAll(descriptor.getConfigurations().get());

        Set<IvyExcludeRule> globalExcludes = descriptor.getGlobalExcludes().getOrNull();
        if (globalExcludes != null) {
            model.globalExcludes.addAll(globalExcludes);
        }

      }
      return this;
    }

    @CanIgnoreReturnValue
    public Builder<E> addAll(Iterable<? extends E> elements) {
      checkNotNull(elements); // for GWT
      for (E element : elements) {
        add(checkNotNull(element));
      }
      return this;
    }

    @CanIgnoreReturnValue
    public Builder<E> addAll(Iterator<? extends E> elements) {
      checkNotNull(elements); // for GWT

        super(message);
        this.message = message;
    }

    public DefaultMultiCauseException(String message, Throwable... causes) {
        super(message);
        this.message = message;
        this.causes.addAll(Arrays.asList(causes));
    }

    public DefaultMultiCauseException(String message, Iterable<? extends Throwable> causes) {
        super(message);
        this.message = message;
        initCauses(causes);
    }

        }
    }

    override fun getSubPackageFqNames(packageFqName: FqName, platform: TargetPlatform, nameFilter: (Name) -> Boolean): Set<Name> =
        buildSet {
            addAll(getKotlinOnlySubPackagesFqNames(packageFqName, nameFilter))
            addAll(getPlatformSpecificSubPackagesFqNames(packageFqName, platform, nameFilter))
        }

    override fun getPlatformSpecificSubPackagesFqNames(
        packageFqName: FqName,

            SymbolExtractorOsConfig symbolExtractorOsConfig = SymbolExtractorOsConfig.current();
            List<String> args = Lists.newArrayList(symbolExtractorOsConfig.getArguments());
            args.addAll(spec.getArgs());
            args.addAll(symbolExtractorOsConfig.getInputOutputFileArguments(spec.getBinaryFile().getAbsolutePath(), spec.getSymbolFile().getAbsolutePath()));
            return args;
        }
    }

            allActions.addAll(parentResolver.getAllCopyActions());
            allActions.addAll(copyActions);
            return allActions;
        }

        @Override
        public List<String> getAllIncludes() {
            List<String> result = new ArrayList<>();
            if (parentResolver != null) {
                result.addAll(parentResolver.getAllIncludes());
            }

        List<ResourceLock> locks = new ArrayList<ResourceLock>(projectLocks.size() + taskLocks.size());
        locks.addAll(projectLocks);
        locks.addAll(taskLocks);
        return withoutLocks(locks, factory);
    }

    @Override
    public void blocking(Runnable action) {
        Registries registries = this.registries.get();