import com.intellij.lang.javascript.psi.JSFile; //导入依赖的package包/类
public void restartInstance() {

        synchronized(this.myLock) {
            final JSGraphQLNodeLanguageServiceInstance instance = JSGraphQLNodeLanguageServiceClient.getLanguageServiceInstance(myProject);
            if(instance != null) {
                if(myToolWindowManager != null) {
                    myToolWindowManager.disconnectFromProcessHandler();
                }
                instance.restart(() -> {
                    final Editor editor = FileEditorManager.getInstance(myProject).getSelectedTextEditor();
                    if(editor != null) {
                        final VirtualFile file = FileDocumentManager.getInstance().getFile(editor.getDocument());
                        if(file != null) {
                            final PsiFile psiFile = PsiUtilCore.getPsiFile(myProject, file);
                            if(psiFile != null) {
                                if(psiFile instanceof JSFile || psiFile instanceof JSGraphQLFile) {
                                    DaemonCodeAnalyzer.getInstance(myProject).restart(psiFile);
                                }
                            }
                            logErrorsForFile(file, true); // force true to re-show the errors for the same file
                        }
                    }
                });
            }
        }
    }
 

import com.intellij.lang.javascript.psi.JSFile; //导入依赖的package包/类
public static String getEnvironment(PsiFile file) {
    if (file instanceof JSFile) {
        // for JS Files we have to check the kind of environment being used
        final Ref<String> envRef = new Ref<>();
        file.accept(new PsiRecursiveElementVisitor() {
            @Override
            public void visitElement(PsiElement element) {
                if (!isJSGraphQLLanguageInjectionTarget(element, envRef)) {
                    // no match yet, so keep visiting
                    super.visitElement(element);
                }
            }
        });
        final String environment = envRef.get();
        if (environment != null) {
            return environment;
        }
    } else if (file instanceof JSGraphQLFile) {
        final Ref<String> tag = new Ref<>();
        if (file.getContext() != null && isJSGraphQLLanguageInjectionTarget(file.getContext(), tag)) {
            return tag.get();
        }
    }
    // fallback is traditional GraphQL
    return GRAPHQL_ENVIRONMENT;
}
 

import com.intellij.lang.javascript.psi.JSFile; //导入依赖的package包/类
@NotNull
@Override
public FormattingModel createModel(PsiElement element, CodeStyleSettings settings) {
    if(element instanceof JSFile || element.getContainingFile() instanceof JSFile) {
        final JSFile file = (JSFile)(element instanceof JSFile ? element : element.getContainingFile());
        file.putUserData(WANT_DEFAULT_FORMATTER_KEY, true);
        try {
            final FormattingModelBuilder formattingModelBuilder = LanguageFormatting.INSTANCE.forContext(file.getLanguage(), element);
            if (formattingModelBuilder != null) {
                final FormattingModel model = formattingModelBuilder.createModel(element, settings);
                final Block rootBlock = model.getRootBlock();
                return new DelegatingFormattingModel(model, new JSGraphQLBlockWrapper(rootBlock, null, element.getNode(), rootBlock.getWrap(), rootBlock.getAlignment(), createSpaceBuilder(settings, element), settings));
            }
        } finally {
            file.putUserData(WANT_DEFAULT_FORMATTER_KEY, null);
        }
    }
    throw new IllegalArgumentException("Unsupported element '" + element + "'. It must be an element in a JSFile with its own default formatter to support injected GraphQL formatting");
}
 

import com.intellij.lang.javascript.psi.JSFile; //导入依赖的package包/类
@Override
public boolean isEngagedToFormat(PsiElement context) {
    if(context instanceof JSFile) {
        if(Boolean.TRUE.equals(context.getUserData(WANT_DEFAULT_FORMATTER_KEY))) {
            // we're looking up the default formatter at the moment
            return false;
        }
        Collection<JSStringTemplateExpression> templateExpressions = PsiTreeUtil.findChildrenOfType(context, JSStringTemplateExpression.class);
        for (JSStringTemplateExpression templateExpression : templateExpressions) {
            if(JSGraphQLLanguageInjectionUtil.isJSGraphQLLanguageInjectionTarget(templateExpression)) {
                return true;
            }
        }
    }
    return false;
}
 

import com.intellij.lang.javascript.psi.JSFile; //导入依赖的package包/类
public void testSnippetsForBackend() {
    PsiFile psiFile = myFixture.configureByFile("snippets.js");

    Collection<ShopwareSnippet> snippetsInFile = SnippetUtil.getSnippetsInFile((JSFile) psiFile);

    assertNotNull(ContainerUtil.find(snippetsInFile, snippet ->
        "backend/foobar/namespace".equals(snippet.getNamespace()) && "start_accept".equals(snippet.getName())
    ));

    assertNotNull(ContainerUtil.find(snippetsInFile, snippet ->
        "backend/foobar".equals(snippet.getNamespace()) && "start_accept".equals(snippet.getName())
    ));

    assertNotNull(ContainerUtil.find(snippetsInFile, snippet ->
        "backend/foobar/namespace".equals(snippet.getNamespace()) && "filter_feature".equals(snippet.getName())
    ));

    assertNotNull(ContainerUtil.find(snippetsInFile, snippet ->
        "foobar".equals(snippet.getNamespace()) && "filter_feature".equals(snippet.getName())
    ));
}
 

import com.intellij.lang.javascript.psi.JSFile; //导入依赖的package包/类
@RequiredReadAction
@NotNull
@Override
public Collection<? extends DotNetTypeDeclaration> findTypesImpl(@NotNull String key, @NotNull GlobalSearchScope searchScope)
{
	if(DumbService.isDumb(myProject))
	{
		return Collections.emptyList();
	}

	Collection<JSFile> jsFiles = UnityScriptFileByNameIndex.getInstance().get(key, myProject, searchScope);
	JSFile jsFile = ContainerUtil.getFirstItem(jsFiles);
	if(jsFile == null)
	{
		return Collections.emptyList();
	}
	return Collections.singletonList(new UnityScriptDotNetTypeDeclaration(key, jsFile));
}
 

import com.intellij.lang.javascript.psi.JSFile; //导入依赖的package包/类
@NotNull
@Override
@RequiredReadAction
public Set<PsiElement> compute(@NotNull final Project project,
		@Nullable final IndexBasedDotNetPsiSearcher searcher,
		@NotNull final String indexKey,
		@NotNull final String thisQName,
		@NotNull final GlobalSearchScope scope)
{
	Set<PsiElement> elements = new LinkedHashSet<>();
	Collection<String> keys = UnityScriptFileByNameIndex.getInstance().getAllKeys(project);
	for(String key : keys)
	{
		ProgressManager.checkCanceled();
		Collection<JSFile> jsFiles = UnityScriptFileByNameIndex.getInstance().get(key, project, scope);
		for(JSFile jsFile : jsFiles)
		{
			elements.add(new UnityScriptDotNetTypeDeclaration(key, jsFile));
		}
	}
	return elements;
}
 

import com.intellij.lang.javascript.psi.JSFile; //导入依赖的package包/类
@Nullable
public static VirtualFile findExecutableFile(ConfigurationContext configurationContext, @Nullable Condition<JSFile> condition)
{
	PsiElement psiLocation = configurationContext.getPsiLocation();
	PsiFile psiFile = psiLocation == null ? null : psiLocation.getContainingFile();
	if(psiFile instanceof JSFile && psiFile.getFileType() == JavaScriptFileType.INSTANCE)
	{
		if(condition != null && !condition.value((JSFile) psiFile))
		{
			return null;
		}
		Module module = configurationContext.getModule();
		if(module == null)
		{
			return null;
		}
		NodeJSModuleExtension extension = ModuleUtilCore.getExtension(module, NodeJSModuleExtension.class);
		if(extension == null)
		{
			return null;
		}
		return psiFile.getVirtualFile();
	}
	return null;
}
 

import com.intellij.lang.javascript.psi.JSFile; //导入依赖的package包/类
@Override
public StubBuilder getBuilder()
{
	return new DefaultStubBuilder()
	{
		@NotNull
		@Override
		protected StubElement createStubForFile(@NotNull PsiFile file)
		{
			if(file instanceof JSFile)
			{
				return new JSFileStubImpl((JSFile) file, file.getName());
			}
			return super.createStubForFile(file);
		}
	};
}
 

import com.intellij.lang.javascript.psi.JSFile; //导入依赖的package包/类
@Override
public String getQualifiedName()
{
	final JSFunctionStub jsFunctionStub = getStub();
	if(jsFunctionStub != null)
	{
		return jsFunctionStub.getQualifiedName();
	}
	final PsiElement parent = JSResolveUtil.findParent(this);

	if(parent instanceof JSFile || parent instanceof JSPackageStatement)
	{
		return JSPsiImplUtils.getQName(this);
	}
	else
	{
		return getName();
	}
}
 

import com.intellij.lang.javascript.psi.JSFile; //导入依赖的package包/类
private static <E extends PsiElement> void process(TokenSet filter, final JSFile file, final ArrayList<E> result, final Collection<JSFile> visited)
{
	if(visited.contains(file))
	{
		return;
	}
	visited.add(file);
	for(PsiElement element : JSResolveUtil.getStubbedChildren(file, filter))
	{
		if(element instanceof JSIncludeDirective)
		{
			PsiFile includedFile = ((JSIncludeDirective) element).resolveFile();
			if(includedFile instanceof JSFile)
			{
				process(filter, (JSFile) includedFile, result, visited);
			}
		}
		else
		{
			result.add((E) element);
		}
	}
}
 

import com.intellij.lang.javascript.psi.JSFile; //导入依赖的package包/类
public static JSImportedElementResolveResult resolveTypeNameUsingImplicitImports(@NotNull String referenceName, @NotNull JSFile file)
{
	final PsiElement context = file.getContext();

	if(context != null)
	{
		JSImportedElementResolveResult expression = tryFindInMap(referenceName, file, implicitImportListMap, null);
		if(expression != null)
		{
			return expression;
		}
		expression = tryFindInMap(referenceName, file, mxmlImportListMap, null);
		if(expression != null)
		{
			return expression;
		}
	}
	return null;
}
 

import com.intellij.lang.javascript.psi.JSFile; //导入依赖的package包/类
@Override
protected CachedValue<JSFile[]> compute(final XmlTag tag, final Object p)
{
	return CachedValuesManager.getManager(tag.getProject()).createCachedValue(new CachedValueProvider<JSFile[]>()
	{
		@Override
		public Result<JSFile[]> compute()
		{
			final List<JSFile> injectedFiles = new ArrayList<JSFile>(2);
			final List<PsiElement> dependencies = new ArrayList<PsiElement>();
			dependencies.add(tag);
			new InjectedScriptsVisitor(tag, doProcessAllTags(tag), false, false, new InjectedFileVisitor()
			{
				@Override
				public void visit(XmlTag rootTag, JSFile file)
				{
					injectedFiles.add(file);
					dependencies.add(file);
				}
			}).go();
			return new Result<JSFile[]>(injectedFiles.toArray(new JSFile[injectedFiles.size()]), dependencies.toArray());
		}
	}, false);
}
 

import com.intellij.lang.javascript.psi.JSFile; //导入依赖的package包/类
protected void evalAnchor(final Editor editor, final PsiFile file)
{
	anchor = null;
	final PsiElement at = file.findElementAt(editor.getCaretModel().getOffset());
	PsiElement parent;

	if(at != null && ((parent = at.getParent()) == myJsClass || (parent instanceof JSFile && myJsClass.getParent().getContainingFile() == parent
			.getContext().getContainingFile())))
	{
		final ASTNode atNode = at.getNode();
		if(atNode.getElementType() == JSTokenTypes.RBRACE)
		{
			return;
		}

		for(ASTNode node = atNode; node != null; node = node.getTreeNext())
		{
			if(node.getElementType() == JSTokenTypes.LBRACE)
			{
				return;
			}
		}
		anchor = at;
	}
}
 

import com.intellij.lang.javascript.psi.JSFile; //导入依赖的package包/类
@RequiredReadAction
private void insertCommitReformat(final Project project, final Editor editor, final PsiFile psiFile, final int offset, final String str,
		final int shiftOffset, boolean adjustLineIndent)
{
	editor.getDocument().insertString(offset, str);
	editor.getCaretModel().moveToOffset(offset + shiftOffset);
	commit(editor);

	PsiElement at = psiFile.findElementAt(offset + shiftOffset - 1);
	final PsiElement parentOfType = PsiTreeUtil.getParentOfType(at, JSStatement.class, JSFunction.class, JSClass.class, JSFile.class);

	try
	{
		reformat(parentOfType);
		if(adjustLineIndent)
		{
			CodeStyleManager.getInstance(project).adjustLineIndent(psiFile, editor.getCaretModel().getOffset());
		}
	}
	catch(IncorrectOperationException ex)
	{
		LoggerFactory.getInstance().getLoggerInstance(getClass().getName()).error(ex);
	}
}
 

import com.intellij.lang.javascript.psi.JSFile; //导入依赖的package包/类
@NotNull
@Override
public Collection<KeyUsagePsiElement> getUsages(PsiFile psiFile) {
    if(psiFile instanceof JSFile) {
        JsEnvironmentCallsVisitor visitor = new JsEnvironmentCallsVisitor();
        psiFile.acceptChildren(visitor);

        return visitor.getCollectedItems();
    }

    return Collections.emptyList();
}
 

import com.intellij.lang.javascript.psi.JSFile; //导入依赖的package包/类
@Override
public boolean isAcceptable(Object element, @Nullable PsiElement context) {
    if (element instanceof XmlAttributeValue && context != null && context.getContainingFile() instanceof JSFile) {
        final XmlAttributeValue value = (XmlAttributeValue) element;
        final XmlAttribute xmlAttribute = PsiTreeUtil.getParentOfType(value, XmlAttribute.class);
        if (xmlAttribute != null) {
            return xmlAttribute.getName().equals("styleName");
        }
    }
    return false;
}
 

import com.intellij.lang.javascript.psi.JSFile; //导入依赖的package包/类
@RequiredReadAction
@Nullable
@Override
public LineMarkerInfo getLineMarkerInfo(@NotNull PsiElement element)
{
	if(element.getNode().getElementType() == JSTokenTypes.IDENTIFIER && element.getParent() instanceof JSReferenceExpression && element.getParent().getParent() instanceof JSFunction)
	{
		UnityFunctionManager functionManager = UnityFunctionManager.getInstance();
		Map<String, UnityFunctionManager.FunctionInfo> map = functionManager.getFunctionsByType().get(Unity3dTypes.UnityEngine.MonoBehaviour);
		if(map == null)
		{
			return null;
		}
		UnityFunctionManager.FunctionInfo functionInfo = map.get(element.getText());
		if(functionInfo == null)
		{
			return null;
		}
		Unity3dModuleExtension extension = ModuleUtilCore.getExtension(element, Unity3dModuleExtension.class);
		if(extension == null)
		{
			return null;
		}
		JSFunction jsFunction = (JSFunction) element.getParent().getParent();
		if(jsFunction.getParent() instanceof JSFile)
		{
			if(!isEqualParameters(functionInfo.getParameters(), jsFunction))
			{
				return null;
			}

			return new LineMarkerInfo<>(element, element.getTextRange(), Unity3dIcons.EventMethod, Pass.LINE_MARKERS, new ConstantFunction<>(functionInfo.getDescription()), null,
					GutterIconRenderer.Alignment.LEFT);
		}
	}
	return null;
}
 

import com.intellij.lang.javascript.psi.JSFile; //导入依赖的package包/类
@Override
public void processElementsWithName(@NotNull String name, @NotNull final Processor<NavigationItem> processor, @NotNull FindSymbolParameters parameters)
{
	StubIndex.getInstance().processElements(UnityScriptIndexKeys.FILE_BY_NAME_INDEX, name, parameters.getProject(), parameters.getSearchScope(), parameters.getIdFilter(), JSFile.class,
			new Processor<JSFile>()
	{
		@Override
		public boolean process(final JSFile file)
		{
			return processor.process(new FakePsiElement()
			{
				@Override
				public String getName()
				{
					return FileUtil.getNameWithoutExtension(file.getName());
				}

				@Nullable
				@Override
				public Icon getIcon(boolean open)
				{
					IconDescriptor descriptor = new IconDescriptor(AllIcons.Nodes.Class);
					descriptor.addLayerIcon(Unity3dIcons.Js);
					descriptor.setRightIcon(AllIcons.Nodes.C_public);
					return descriptor.toIcon();
				}

				@Override
				public PsiElement getParent()
				{
					return file;
				}
			});
		}
	});
}
 

import com.intellij.lang.javascript.psi.JSFile; //导入依赖的package包/类
@Override
@RequiredDispatchThread
public Collection<AbstractTreeNode> modify(AbstractTreeNode parent, Collection<AbstractTreeNode> children, ViewSettings settings)
{
	if(!myProject.isInitialized())
	{
		return children;
	}
	Unity3dRootModuleExtension rootModuleExtension = Unity3dModuleExtensionUtil.getRootModuleExtension(myProject);
	if(rootModuleExtension == null)
	{
		return children;
	}

	List<AbstractTreeNode> nodes = new ArrayList<AbstractTreeNode>(children.size());
	for(AbstractTreeNode child : children)
	{
		Object value = child.getValue();
		if(value instanceof JSFile)
		{
			Module moduleForPsiElement = ModuleUtilCore.findModuleForPsiElement((PsiElement) value);
			if(moduleForPsiElement != null)
			{
				nodes.add(new UnityScriptFileNode(myProject, (PsiFile) value, settings));
				continue;
			}
		}
		nodes.add(child);
	}
	return nodes;
}