com.jetbrains.pluginverifier.resolution.PluginApiClassResolverProvider.kt Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of verifier-intellij Show documentation

JetBrains Plugin Verifier Classes for IntelliJ Platform integration with API usage detection and reporting.

There is a newer version: 1.381

/*
 * Copyright 2000-2020 JetBrains s.r.o. and other contributors. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
 */

package com.jetbrains.pluginverifier.resolution

import com.jetbrains.plugin.structure.base.utils.closeOnException
import com.jetbrains.plugin.structure.classes.resolvers.CompositeResolver
import com.jetbrains.plugin.structure.intellij.plugin.PluginDependencyImpl
import com.jetbrains.pluginverifier.createPluginResolver
import com.jetbrains.pluginverifier.dependencies.DependenciesGraph
import com.jetbrains.pluginverifier.dependencies.DependencyEdge
import com.jetbrains.pluginverifier.dependencies.DependencyNode
import com.jetbrains.pluginverifier.jdk.JdkDescriptor
import com.jetbrains.pluginverifier.plugin.PluginDetails
import com.jetbrains.pluginverifier.verifiers.packages.NegatedPackageFilter
import com.jetbrains.pluginverifier.verifiers.packages.PackageFilter
import com.jetbrains.pluginverifier.verifiers.resolution.caching
import java.io.Closeable

class PluginApiClassResolverProvider(
  private val jdkDescriptor: JdkDescriptor,
  private val basePluginDetails: PluginDetails,
  private val basePluginPackageFilter: PackageFilter
) : ClassResolverProvider {

  override fun provide(checkedPluginDetails: PluginDetails): ClassResolverProvider.Result {
    val closeableResources = arrayListOf()
    closeableResources.closeOnException {
      val checkedPluginClassResolver = checkedPluginDetails.pluginClassesLocations.createPluginResolver()
      val basePluginResolver = basePluginDetails.pluginClassesLocations.createPluginResolver()

      /**
       * Resolves classes in the following order:
       * 1) Verified plugin
       * 2) Classes of a plugin against which the plugin is verified
       * 3) Classes of JDK
       *
       * A class is considered external if:
       * 1) [basePluginResolver] doesn't contain it in class files
       * 2) [basePluginPackageFilter] rejects it, meaning that the class does not reside in the base plugin
       *
       * For instance, if the class is expected to reside in the base plugin and is not resolved among its classes,
       * a "Class not found" problem will be reported.
       */
      val resolver = CompositeResolver.create(checkedPluginClassResolver, basePluginResolver, jdkDescriptor.jdkResolver).caching()

      val checkedPluginNode = DependencyNode(
        checkedPluginDetails.pluginInfo.pluginId,
        checkedPluginDetails.pluginInfo.version
      )

      val basePluginNode = DependencyNode(
        basePluginDetails.pluginInfo.pluginId,
        basePluginDetails.pluginInfo.version
      )

      val dependenciesGraph = DependenciesGraph(
        checkedPluginNode,
        listOf(checkedPluginNode, basePluginNode),
        listOf(
          DependencyEdge(
            checkedPluginNode,
            basePluginNode,
            PluginDependencyImpl(basePluginNode.pluginId, false, false)
          )
        ),
        emptyMap()
      )

      return ClassResolverProvider.Result(
        checkedPluginClassResolver,
        resolver,
        dependenciesGraph,
        closeableResources
      )
    }
  }

  override fun provideExternalClassesPackageFilter() = NegatedPackageFilter(basePluginPackageFilter)

}