import com.intellij.execution.JavaExecutionUtil; //导入依赖的package包/类
public void executeConfiguration(Project project, ModuleBasedConfiguration appCon) {
    if (noProjectsAreOpen()) {
        logger.warn("No open projects found, can't execute the project.");
        return;
    }
    logger.info("Starting to build execution environment.");
    RunManager runManager = RunManager.getInstance(project);
    Executor executor = DefaultRunExecutor.getRunExecutorInstance();
    RunnerAndConfigurationSettingsImpl selectedConfiguration =
            getApplicationRunnerAndConfigurationSettings(runManager, appCon);
    ProgramRunner runner = getRunner(executor, selectedConfiguration);
    logger.info("Creating ExecutionEnvironment.");
    ExecutionEnvironment environment =
            new ExecutionEnvironment(
                    new DefaultRunExecutor(), runner, selectedConfiguration, project);
    try {
        logger.info("Executing project.");
        runner.execute(environment);
    } catch (ExecutionException e1) {
        JavaExecutionUtil.showExecutionErrorMessage(e1, "Error", project);
    }
}
 

import com.intellij.execution.JavaExecutionUtil; //导入依赖的package包/类
@Override
public boolean isConfigurationFromContext(T appConfiguration, ConfigurationContext context) {
  final PsiElement location = context.getPsiLocation();
  final PsiClass aClass = ApplicationConfigurationType.getMainClass(location);
  if (aClass != null && Comparing.equal(JavaExecutionUtil.getRuntimeQualifiedName(aClass), appConfiguration.MAIN_CLASS_NAME)) {
    final PsiMethod method = PsiTreeUtil.getParentOfType(location, PsiMethod.class, false);
    if (method != null && TestFrameworks.getInstance().isTestMethod(method)) {
      return false;
    }

    final Module configurationModule = appConfiguration.getConfigurationModule().getModule();
    if (Comparing.equal(context.getModule(), configurationModule)) return true;

    ApplicationConfiguration template =
      (ApplicationConfiguration)context.getRunManager().getConfigurationTemplate(getConfigurationFactory()).getConfiguration();
    final Module predefinedModule = template.getConfigurationModule().getModule();
    if (Comparing.equal(predefinedModule, configurationModule)) {
      return true;
    }
  }
  return false;
}
 

import com.intellij.execution.JavaExecutionUtil; //导入依赖的package包/类
public ClassPackageAccessor(final RefactoringListeners.Accessor<PsiClass> accessor) {
  myAccessor = accessor;
  PsiClass aClass = myAccessor.getPsiElement();
  aClass = (PsiClass)aClass.getOriginalElement();
  myContainingPackage = JavaDirectoryService.getInstance().getPackage(aClass.getContainingFile().getContainingDirectory());
  myModule = JavaExecutionUtil.findModule(aClass);
  final String classQName = aClass.getQualifiedName();
  final String classPackageQName = myContainingPackage.getQualifiedName();
  if (classQName.startsWith(classPackageQName)) {
    final String inpackageName = classQName.substring(classPackageQName.length());
    if (StringUtil.startsWithChar(inpackageName, '.')) {
      myInpackageName = inpackageName.substring(1);
    }
    else {
      myInpackageName = inpackageName;
    }
  }
  else {
    myInpackageName = null;
  }
}
 

import com.intellij.execution.JavaExecutionUtil; //导入依赖的package包/类
@Override
public boolean isConfigurationFromContext(JavaScratchConfiguration configuration, ConfigurationContext context) {
  final PsiElement location = context.getPsiLocation();
  final PsiClass aClass = ApplicationConfigurationType.getMainClass(location);
  if (aClass != null && Comparing.equal(JavaExecutionUtil.getRuntimeQualifiedName(aClass), configuration.MAIN_CLASS_NAME)) {
    // for scratches it is enough to check that the configuration is associated with the same scratch file
    final VirtualFile scratchFile = configuration.getScratchVirtualFile();
    if (scratchFile != null) {
      final PsiFile containingFile = aClass.getContainingFile();
      if (containingFile != null && scratchFile.equals(containingFile.getVirtualFile())) {
        return true;
      }
    }
  }
  return false;
}
 

import com.intellij.execution.JavaExecutionUtil; //导入依赖的package包/类
@Nullable("null if class not found")
public static Boolean isClassInProductionSources(@NotNull String mainClassName, @NotNull Module module) {
  final PsiClass psiClass = JavaExecutionUtil.findMainClass(module, mainClassName);
  if (psiClass == null) {
    return null;
  }
  final PsiFile psiFile = psiClass.getContainingFile();
  if (psiFile == null) return null;
  final VirtualFile virtualFile = psiFile.getVirtualFile();
  if (virtualFile == null) return null;
  Module classModule = psiClass.isValid() ? ModuleUtilCore.findModuleForPsiElement(psiClass) : null;
  if (classModule == null) classModule = module;
  ModuleFileIndex fileIndex = ModuleRootManager.getInstance(classModule).getFileIndex();
  if (fileIndex.isInSourceContent(virtualFile)) {
    return !fileIndex.isInTestSourceContent(virtualFile);
  }
  final List<OrderEntry> entriesForFile = fileIndex.getOrderEntriesForFile(virtualFile);
  for (OrderEntry entry : entriesForFile) {
    if (entry instanceof ExportableOrderEntry && ((ExportableOrderEntry)entry).getScope() == DependencyScope.TEST) {
      return false;
    }
  }
  return true;
}
 

import com.intellij.execution.JavaExecutionUtil; //导入依赖的package包/类
private static boolean isAppletClass(final PsiClass aClass, final PsiManager manager) {
  if (!PsiClassUtil.isRunnableClass(aClass, true)) return false;

  final Module module = JavaExecutionUtil.findModule(aClass);
  final GlobalSearchScope scope = module != null
                            ? GlobalSearchScope.moduleWithLibrariesScope(module)
                            : GlobalSearchScope.projectScope(manager.getProject());
  PsiClass appletClass = JavaPsiFacade.getInstance(manager.getProject()).findClass("java.applet.Applet", scope);
  if (appletClass != null) {
    if (aClass.isInheritor(appletClass, true)) return true;
  }
  appletClass = JavaPsiFacade.getInstance(manager.getProject()).findClass("javax.swing.JApplet", scope);
  if (appletClass != null) {
    if (aClass.isInheritor(appletClass, true)) return true;
  }
  return false;
}
 

import com.intellij.execution.JavaExecutionUtil; //导入依赖的package包/类
@Nullable
private static PsiClass getActivityClass(Location location, ConfigurationContext context) {
  final Module module = context.getModule();
  if (module == null) return null;
  location = JavaExecutionUtil.stepIntoSingleClass(location);
  if (location == null) {
    return null;
  }
  PsiElement element = location.getPsiElement();
  JavaPsiFacade facade = JavaPsiFacade.getInstance(element.getProject());
  GlobalSearchScope scope = module.getModuleWithDependenciesAndLibrariesScope(true);
  PsiClass activityClass = facade.findClass(AndroidUtils.ACTIVITY_BASE_CLASS_NAME, scope);
  if (activityClass == null) return null;

  PsiClass elementClass = PsiTreeUtil.getParentOfType(element, PsiClass.class, false);
  while (elementClass != null) {
    if (elementClass.isInheritor(activityClass, true)) {
      return elementClass;
    }
    elementClass = PsiTreeUtil.getParentOfType(elementClass, PsiClass.class);
  }
  return null;
}
 

import com.intellij.execution.JavaExecutionUtil; //导入依赖的package包/类
@Override
@Nullable
public RefactoringElementListener getRefactoringElementListener(PsiElement element) {
  return RefactoringListeners.getClassOrPackageListener(element, new RefactoringListeners.Accessor<PsiClass>() {
    @Override
    public void setName(String qualifiedName) {
      ACTIVITY_CLASS = qualifiedName;
    }

    @Nullable
    @Override
    public PsiClass getPsiElement() {
      return getConfigurationModule().findClass(ACTIVITY_CLASS);
    }

    @Override
    public void setPsiElement(PsiClass psiClass) {
      ACTIVITY_CLASS = JavaExecutionUtil.getRuntimeQualifiedName(psiClass);
    }
  });
}
 

import com.intellij.execution.JavaExecutionUtil; //导入依赖的package包/类
@Nullable
protected String selectListenerClass() {
  GlobalSearchScope searchScope = getSearchScope(config.getModules());
  if (searchScope == null) {
    searchScope = GlobalSearchScope.allScope(project);
  }
  final TestListenerFilter filter = new TestListenerFilter(searchScope, project);

  TreeClassChooser chooser = TreeClassChooserFactory.getInstance(project)
    .createWithInnerClassesScopeChooser("Choose Listener Class", filter.getScope(), filter, null);
  chooser.showDialog();
  PsiClass psiclass = chooser.getSelected();
  if (psiclass == null) {
    return null;
  }
  else {
    return JavaExecutionUtil.getRuntimeQualifiedName(psiclass);
  }
}
 

import com.intellij.execution.JavaExecutionUtil; //导入依赖的package包/类
@Override
public boolean isConfiguredByElement(final JUnitConfiguration configuration,
                                     PsiClass testClass,
                                     PsiMethod testMethod,
                                     PsiPackage testPackage,
                                     PsiDirectory testDir) {

  if (testClass == null) {
    return false;
  }
  if (testMethod != null) {
    // 'test class' configuration is not equal to the 'test method' configuration!
    return false;
  }
  return Comparing.equal(JavaExecutionUtil.getRuntimeQualifiedName(testClass), configuration.getPersistentData().getMainClassName());
}
 

import com.intellij.execution.JavaExecutionUtil; //导入依赖的package包/类
@Override
public void checkConfiguration() throws RuntimeConfigurationException {
  final JUnitConfiguration.Data data = getConfiguration().getPersistentData();
  final Set<String> patterns = data.getPatterns();
  if (patterns.isEmpty()) {
    throw new RuntimeConfigurationWarning("No pattern selected");
  }
  final GlobalSearchScope searchScope = GlobalSearchScope.allScope(getConfiguration().getProject());
  for (String pattern : patterns) {
    final String className = pattern.contains(",") ? StringUtil.getPackageName(pattern, ',') : pattern;
    final PsiClass psiClass = JavaExecutionUtil.findMainClass(getConfiguration().getProject(), className, searchScope);
    if (psiClass != null && !JUnitUtil.isTestClass(psiClass)) {
      throw new RuntimeConfigurationWarning("Class " + className + " not a test");
    }
  }
}
 

import com.intellij.execution.JavaExecutionUtil; //导入依赖的package包/类
@Nullable
private RunnerAndConfigurationSettings createConfiguration(@Nullable final PsiClass aClass) {
  if (aClass == null) return null;

  final Project project = aClass.getProject();
  RunnerAndConfigurationSettings settings = RunManagerEx.getInstanceEx(project).createConfiguration("", getConfigurationFactory());
  final GroovyScriptRunConfiguration configuration = (GroovyScriptRunConfiguration)settings.getConfiguration();
  final PsiFile file = aClass.getContainingFile().getOriginalFile();
  final PsiDirectory dir = file.getContainingDirectory();
  if (dir != null) {
    configuration.setWorkDir(dir.getVirtualFile().getPath());
  }
  final VirtualFile vFile = file.getVirtualFile();
  if (vFile == null) return null;
  String path = ScriptFileUtil.getScriptFilePath(vFile);
  configuration.setScriptPath(path);
  RunConfigurationModule module = configuration.getConfigurationModule();

  String name = GroovyRunnerUtil.getConfigurationName(aClass, module);
  configuration.setName(StringUtil.isEmpty(name) ? vFile.getName() : name);
  configuration.setModule(JavaExecutionUtil.findModule(aClass));
  return settings;
}
 

import com.intellij.execution.JavaExecutionUtil; //导入依赖的package包/类
@Override
protected PsiClass findClass(String className) {
  final Set<Module> modules = ApplicationManager.getApplication().runReadAction(new Computable<Set<Module>>() {
    @Override
    public Set<Module> compute() {
      return ArtifactUtil.getModulesIncludedInArtifacts(Collections.singletonList(myArtifact), getProject());
    }
  });
  for (Module module : modules) {
    final PsiClass aClass = JavaExecutionUtil.findMainClass(getProject(), className, GlobalSearchScope.moduleScope(module));
    if (aClass != null) {
      return aClass;
    }
  }
  return null;
}
 

import com.intellij.execution.JavaExecutionUtil; //导入依赖的package包/类
@Nullable
private static PsiClass getMainClass(ConfigurationContext context) {
  Location location = context.getLocation();
  if (location == null) {
    return null;
  }
  location = JavaExecutionUtil.stepIntoSingleClass(location);
  if (location == null) {
    return null;
  }
  PsiElement element = location.getPsiElement();
  if (!element.isPhysical()) {
    return null;
  }
  return ApplicationConfigurationType.getMainClass(element);
}
 

import com.intellij.execution.JavaExecutionUtil; //导入依赖的package包/类
@Nullable
private static ScClass getTestClass(ConfigurationContext context) {
  Location<?> location = context.getLocation();
  if (location == null) {
    return null;
  }
  location = JavaExecutionUtil.stepIntoSingleClass(location);
  if (location == null) {
    return null;
  }
  if (!SmRunnerUtils.getSelectedSmRunnerTreeElements(context).isEmpty()) {
    // handled by a different producer
    return null;
  }
  return getTestClass(location);
}
 

import com.intellij.execution.JavaExecutionUtil; //导入依赖的package包/类
@Nullable
private static ScObject getMainObject(ConfigurationContext context) {
  Location location = context.getLocation();
  if (location == null) {
    return null;
  }
  location = JavaExecutionUtil.stepIntoSingleClass(context.getLocation());
  if (location == null) {
    return null;
  }
  PsiElement element = location.getPsiElement();
  if (!(element.getContainingFile() instanceof ScalaFile)) {
    return null;
  }
  if (!element.isPhysical()) {
    return null;
  }
  return getMainObjectFromElement(element);
}
 

import com.intellij.execution.JavaExecutionUtil; //导入依赖的package包/类
public static boolean isValidMainClass(@Nullable final Module module, @Nullable final String className) {
  if(module == null || className == null) {
    return false;
  }

  final DefracFacet facet = DefracFacet.getInstance(module);

  if(facet == null) {
    return false;
  }

  if(facet.getPlatform().isAndroid()) {
    final PsiClass psiClass = JavaPsiFacade.getInstance(module.getProject()).findClass(className, module.getModuleScope());

    return psiClass != null && findActivityClass(module, psiClass) != null;
  }

  return JavaExecutionUtil.findMainClass(module.getProject(), className, module.getModuleScope()) != null;
}
 

import com.intellij.execution.JavaExecutionUtil; //导入依赖的package包/类
@Override
public boolean isConfigurationFromContext(ApplicationConfiguration appConfiguration, ConfigurationContext context) {
  final PsiClass aClass = ApplicationConfigurationType.getMainClass(context.getPsiLocation());
  if (aClass != null && Comparing.equal(JavaExecutionUtil.getRuntimeQualifiedName(aClass), appConfiguration.MAIN_CLASS_NAME)) {
    final Module configurationModule = appConfiguration.getConfigurationModule().getModule();
    if (Comparing.equal(context.getModule(), configurationModule)) return true;

    ApplicationConfiguration template = (ApplicationConfiguration)context.getRunManager()
      .getConfigurationTemplate(getConfigurationFactory())
      .getConfiguration();
    final Module predefinedModule = template.getConfigurationModule().getModule();
    if (Comparing.equal(predefinedModule, configurationModule)) {
      return true;
    }
  }
  return false;
}
 

import com.intellij.execution.JavaExecutionUtil; //导入依赖的package包/类
@Nullable
protected String showDialog() {
  final ClassFilter.ClassFilterWithScope classFilter;
  try {
    classFilter = getFilter();
  }
  catch (NoFilterException e) {
    final MessagesEx.MessageInfo info = e.getMessageInfo();
    info.showNow();
    return null;
  }
  final TreeClassChooser dialog = createClassChooser(classFilter);
  configureDialog(dialog);
  dialog.showDialog();
  final PsiClass psiClass = dialog.getSelected();
  if (psiClass == null) return null;
  onClassChoosen(psiClass);
  return JavaExecutionUtil.getRuntimeQualifiedName(psiClass);
}
 

import com.intellij.execution.JavaExecutionUtil; //导入依赖的package包/类
public static int getClasspathType(final RunConfigurationModule configurationModule, final String mainClassName,
                                   final boolean classMustHaveSource) throws CantRunException {
  final Module module = configurationModule.getModule();
  if (module == null) throw CantRunException.noModuleConfigured(configurationModule.getModuleName());
  final PsiClass psiClass = JavaExecutionUtil.findMainClass(module, mainClassName);
  if (psiClass == null) {
    if (!classMustHaveSource) return JavaParameters.JDK_AND_CLASSES_AND_TESTS;
    throw CantRunException.classNotFound(mainClassName, module);
  }
  final PsiFile psiFile = psiClass.getContainingFile();
  if (psiFile == null) throw CantRunException.classNotFound(mainClassName, module);
  final VirtualFile virtualFile = psiFile.getVirtualFile();
  if (virtualFile == null) throw CantRunException.classNotFound(mainClassName, module);
  Module classModule = psiClass.isValid() ? ModuleUtilCore.findModuleForPsiElement(psiClass) : null;
  if (classModule == null) classModule = module;
  ModuleFileIndex fileIndex = ModuleRootManager.getInstance(classModule).getFileIndex();
  if (fileIndex.isInSourceContent(virtualFile)) {
    return fileIndex.
      isInTestSourceContent(virtualFile) ? JavaParameters.JDK_AND_CLASSES_AND_TESTS : JavaParameters.JDK_AND_CLASSES;
  }
  final List<OrderEntry> entriesForFile = fileIndex.getOrderEntriesForFile(virtualFile);
  for (OrderEntry entry : entriesForFile) {
    if (entry instanceof ExportableOrderEntry && ((ExportableOrderEntry)entry).getScope() == DependencyScope.TEST) return JavaParameters.JDK_AND_CLASSES_AND_TESTS;
  }
  return JavaParameters.JDK_AND_CLASSES;
}