public static void removeVariable(GrVariable variable) {
    final GrVariableDeclaration varDecl = (GrVariableDeclaration) variable.getParent();
    final List<GrVariable> variables = Arrays.asList(varDecl.getVariables());
    if (!variables.contains(variable)) {
      throw new IllegalArgumentException();
    }

    final PsiElement parent = varDecl.getParent();
    final ASTNode owner = parent.getNode();
    if (variables.size() == 1 && owner != null) {
      PsiElement next = varDecl.getNextSibling();

      // remove redundant semicolons
      //noinspection ConstantConditions
      while (next != null && next.getNode() != null && next.getNode().getElementType() == mSEMI) {
        PsiElement tmpNext = next.getNextSibling();
        //noinspection ConstantConditions
        next.delete();
        next = tmpNext;
      }

      removeNewLineAfter(varDecl);
      varDecl.delete();
      return;
    }
    variable.delete();
  }
 public static void deleteStatementTail(PsiElement container, @NotNull PsiElement statement) {
   PsiElement next = statement.getNextSibling();
   while (next != null) {
     final ASTNode node = next.getNode();
     final IElementType type = node.getElementType();
     if (type == mSEMI) {
       final PsiElement nnext = next.getNextSibling();
       container.deleteChildRange(next, next);
       next = nnext;
     } else if (type == mNLS || type == TokenType.WHITE_SPACE && next.getText().contains("\n")) {
       final String text = next.getText();
       final int first = text.indexOf("\n");
       final int second = text.indexOf("\n", first + 1);
       if (second < 0) {
         container.deleteChildRange(next, next);
         return;
       }
       final String substring = text.substring(second);
       container
           .getNode()
           .replaceChild(
               node,
               createSingleLeafElement(
                   type, substring, 0, substring.length(), null, container.getManager()));
       return;
     } else {
       break;
     }
   }
 }
Esempio n. 3
0
 public static PsiElement getChild(
     final PsiElement parent,
     int position,
     boolean ignoreWhiteSpaces,
     boolean ignoreComments,
     boolean ignoreErrors) {
   PsiElement curChild = parent.getFirstChild();
   int i = 0;
   while (i <= position && curChild != null) {
     if (WHITE_SPACES.contains(curChild.getNode().getElementType())) {
       if (!ignoreWhiteSpaces) i++;
       curChild = curChild.getNextSibling();
     } else if (COMMENTS.contains(curChild.getNode().getElementType())) {
       if (!ignoreComments) i++;
       curChild = curChild.getNextSibling();
     } else if (curChild instanceof PsiErrorElement) {
       if (!ignoreErrors) {
         return null;
       }
       i++;
       curChild = curChild.getNextSibling();
     } else {
       if (i == position) return curChild;
       i++;
       curChild = curChild.getNextSibling();
     }
   }
   return null;
 }
  @Nullable
  @Override
  protected Indent getChildIndent(@Nullable PsiElement prevChild, @Nullable PsiElement child) {
    if (prevChild != null && child != null && !inTheSameLine(prevChild.getNode(), child.getNode()))
      return Indent.getNormalIndent();

    return super.getChildIndent(prevChild, child);
  }
  public void replaceDotToken(PsiElement newDot) {
    if (newDot == null) return;
    if (!TokenSets.DOTS.contains(newDot.getNode().getElementType())) return;
    final PsiElement oldDot = getDotToken();
    if (oldDot == null) return;

    getNode().replaceChild(oldDot.getNode(), newDot.getNode());
  }
  public boolean isFunctionCall() {
    PsiElement commandElement = commandElement();
    if (commandElement == null || commandElement.getNode() == null) {
      return false;
    }

    return commandElement.getNode().getElementType() == BashElementTypes.GENERIC_COMMAND_ELEMENT
        && internalResolve() != null;
  }
Esempio n. 7
0
 @Nullable
 public static PsiElement searchNonSpaceNonCommentBack(PsiElement element) {
   if (element == null || element.getNode() == null) return null;
   ASTNode leftNeibour = TreeUtil.prevLeaf(element.getNode());
   while (leftNeibour != null
       && (leftNeibour.getElementType() == TokenType.WHITE_SPACE
           || leftNeibour.getPsi() instanceof PsiComment)) {
     leftNeibour = TreeUtil.prevLeaf(leftNeibour);
   }
   return leftNeibour != null ? leftNeibour.getPsi() : null;
 }
  public PsiElement handleElementRename(String newName) throws IncorrectOperationException {
    if (StringUtil.isEmpty(newName)) {
      return null;
    }

    final PsiElement original = commandElement();
    final PsiElement replacement = BashChangeUtil.createWord(getProject(), newName);

    getNode().replaceChild(original.getNode(), replacement.getNode());
    return this;
  }
  private int computeIndentCount(IDocument document, int offset) {
    try {
      if (offset == document.getLength()) {
        return 0;
      }

      IFile file = EditorUtil.getFile(editor);
      if (file == null) {
        KotlinLogger.logError("Failed to retrieve IFile from editor " + editor, null);
        return 0;
      }

      if (document.get().contains(LineEndUtil.CARRIAGE_RETURN_STRING)) {
        offset -= document.getLineOfOffset(offset);
      }

      PsiFile parsedDocument = KotlinPsiManager.getKotlinFileIfExist(file, document.get());
      if (parsedDocument == null) {
        return 0;
      }

      PsiElement leaf = parsedDocument.findElementAt(offset);
      if (leaf == null) {
        return 0;
      }

      if (leaf.getNode().getElementType() != JetTokens.WHITE_SPACE) {
        leaf = parsedDocument.findElementAt(offset - 1);
      }

      int indent = 0;

      ASTNode node = null;
      if (leaf != null) {
        node = leaf.getNode();
      }
      while (node != null) {
        indent = AlignmentStrategy.updateIndent(node, indent);
        node = node.getTreeParent();
      }

      return indent;
    } catch (BadLocationException e) {
      KotlinLogger.logAndThrow(e);
    }

    return 0;
  }
  public static GrDocComment setDocComment(
      @NotNull GrDocCommentOwner owner, @Nullable GrDocComment comment) {
    GrDocComment docComment = owner.getDocComment();

    if (docComment != null) {
      if (comment == null) {
        docComment.delete();
        return null;
      } else {
        PsiElement added = docComment.replace(comment);
        assert added instanceof GrDocComment;
        return (GrDocComment) added;
      }
    } else {
      if (comment == null) return null;

      PsiElement parent = owner.getParent();

      ASTNode node = owner.getNode();
      parent.getNode().addLeaf(GroovyTokenTypes.mNLS, "\n ", node);

      PsiElement added = parent.addBefore(comment, owner);
      assert added instanceof GrDocComment;

      return (GrDocComment) added;
    }
  }
 /**
  * Adds all children of specified element to given list
  *
  * @param elem
  * @param list
  * @param indent
  * @param aligner
  */
 private void addBinaryChildrenRecursively(
     PsiElement elem,
     List<Block> list,
     Indent indent,
     @Nullable AlignmentProvider.Aligner aligner) {
   if (elem == null) return;
   // For binary expressions
   if ((elem instanceof GrBinaryExpression)) {
     GrBinaryExpression myExpr = ((GrBinaryExpression) elem);
     if (myExpr.getLeftOperand() instanceof GrBinaryExpression) {
       addBinaryChildrenRecursively(
           myExpr.getLeftOperand(), list, Indent.getContinuationWithoutFirstIndent(), aligner);
     }
     PsiElement op = ((GrBinaryExpression) elem).getOperationToken();
     for (ASTNode childNode : visibleChildren(elem.getNode())) {
       PsiElement psi = childNode.getPsi();
       if (!(psi instanceof GrBinaryExpression)) {
         if (op != psi && aligner != null) {
           aligner.append(psi);
         }
         list.add(
             new GroovyBlock(
                 childNode, indent, myWrap, mySettings, myGroovySettings, myAlignmentProvider));
       }
     }
     if (myExpr.getRightOperand() instanceof GrBinaryExpression) {
       addBinaryChildrenRecursively(
           myExpr.getRightOperand(), list, Indent.getContinuationWithoutFirstIndent(), aligner);
     }
   }
 }
  public static UsageGroup getUsageGroupingRule(PsiElement element) {
    final PsiElement[] etype = {null};
    ASTTreeProcessor treeProcessor = new ASTTreeProcessor();
    treeProcessor.add(
        new ASTNodeHandler() {
          @NotNull
          public TokenSet getTokenSet() {
            return TokenSet.create(
                PlSqlElementTypes.FUNCTION_BODY, PlSqlElementTypes.PROCEDURE_BODY);
          }

          public boolean handleNode(@NotNull ASTNode node) {
            etype[0] = node.getPsi();
            return true;
          }
        });

    treeProcessor.process(element.getNode(), true /* break on first hit*/);

    if (etype[0] == null || etype[0].getNode() == null) {
      return null;
    }

    if (etype[0].getNode().getElementType() == PlSqlElementTypes.FUNCTION_BODY) {
      return new FunctionBodyUsageGroup((Function) etype[0]);
    } else if (etype[0].getNode().getElementType() == PlSqlElementTypes.PROCEDURE_BODY) {
      return new ProcedureBodyUsageGroup((Procedure) etype[0]);
    }

    return null;
  }
  @Override
  public void checkFile(
      @NotNull PsiFile originalFile,
      @NotNull final InspectionManager manager,
      @NotNull ProblemsHolder problemsHolder,
      @NotNull final GlobalInspectionContext globalContext,
      @NotNull final ProblemDescriptionsProcessor problemDescriptionsProcessor) {
    for (Pair<PsiFile, HighlightInfo> pair :
        runGeneralHighlighting(originalFile, highlightErrorElements, runAnnotators)) {
      PsiFile file = pair.first;
      HighlightInfo info = pair.second;
      TextRange range = new TextRange(info.startOffset, info.endOffset);
      PsiElement element = file.findElementAt(info.startOffset);

      while (element != null && !element.getTextRange().contains(range)) {
        element = element.getParent();
      }

      if (element == null) {
        element = file;
      }

      GlobalInspectionUtil.createProblem(
          element,
          info,
          range.shiftRight(-element.getNode().getStartOffset()),
          info.getProblemGroup(),
          manager,
          problemDescriptionsProcessor,
          globalContext);
    }
  }
 /**
  * Adds all children of specified element to given list
  *
  * @param elem
  * @param list
  * @param indent
  * @param alignment
  */
 private void addBinaryChildrenRecursively(
     PsiElement elem, List<Block> list, Indent indent, Alignment alignment) {
   if (elem == null) return;
   // For binary expressions
   if ((elem instanceof GrBinaryExpression)) {
     GrBinaryExpression myExpr = ((GrBinaryExpression) elem);
     if (myExpr.getLeftOperand() instanceof GrBinaryExpression) {
       addBinaryChildrenRecursively(
           myExpr.getLeftOperand(), list, Indent.getContinuationWithoutFirstIndent(), alignment);
     }
     PsiElement op = ((GrBinaryExpression) elem).getOperationToken();
     for (ASTNode childNode : visibleChildren(elem.getNode())) {
       PsiElement psi = childNode.getPsi();
       if (!(psi instanceof GrBinaryExpression)) {
         Alignment alignmentToUse = op == psi ? myInnerAlignments.get(op) : alignment;
         list.add(
             new GroovyBlock(
                 childNode,
                 alignmentToUse,
                 indent,
                 myWrap,
                 mySettings,
                 myGroovySettings,
                 myInnerAlignments));
       }
     }
     if (myExpr.getRightOperand() instanceof GrBinaryExpression) {
       addBinaryChildrenRecursively(
           myExpr.getRightOperand(), list, Indent.getContinuationWithoutFirstIndent(), alignment);
     }
   }
 }
  @NotNull
  public GrAnnotation addAnnotation(@NotNull @NonNls String qualifiedName) {
    final PsiClass psiClass =
        JavaPsiFacade.getInstance(getProject()).findClass(qualifiedName, getResolveScope());
    final GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(getProject());
    GrAnnotation annotation;
    if (psiClass != null && psiClass.isAnnotationType()) {
      annotation = (GrAnnotation) addAfter(factory.createModifierFromText("@xxx"), null);
      annotation.getClassReference().bindToElement(psiClass);
    } else {
      annotation =
          (GrAnnotation) addAfter(factory.createModifierFromText("@" + qualifiedName), null);
    }

    final PsiElement parent = getParent();
    if (!(parent instanceof GrParameter)) {
      final ASTNode node = annotation.getNode();
      final ASTNode treeNext = node.getTreeNext();
      if (treeNext != null) {
        getNode().addLeaf(TokenType.WHITE_SPACE, "\n", treeNext);
      } else {
        parent.getNode().addLeaf(TokenType.WHITE_SPACE, "\n", getNode().getTreeNext());
      }
    }

    return annotation;
  }
 @Override
 public boolean value(PsiElement element) {
   if (element.getNode().getElementType() == RegExpTT.CHARACTER || element instanceof RegExpChar) {
     return false;
   }
   return true;
 }
  private int getPrevOrNextParameterOffset(boolean isNext) {
    if (!(myHandler instanceof ParameterInfoHandlerWithTabActionSupport)) return -1;
    ParameterInfoHandlerWithTabActionSupport handler =
        (ParameterInfoHandlerWithTabActionSupport) myHandler;

    boolean noDelimiter = handler.getActualParameterDelimiterType() == TokenType.WHITE_SPACE;
    int caretOffset = myEditor.getCaretModel().getOffset();
    int offset =
        noDelimiter
            ? caretOffset
            : CharArrayUtil.shiftBackward(
                    myEditor.getDocument().getCharsSequence(), caretOffset - 1, " \t")
                + 1;
    int lbraceOffset = myLbraceMarker.getStartOffset();
    PsiFile file = PsiDocumentManager.getInstance(myProject).getPsiFile(myEditor.getDocument());
    PsiElement argList =
        lbraceOffset < offset ? findArgumentList(file, offset, lbraceOffset) : null;
    if (argList == null) return -1;

    @SuppressWarnings("unchecked")
    PsiElement[] parameters = handler.getActualParameters(argList);
    int currentParameterIndex =
        noDelimiter
            ? JBIterable.of(parameters).indexOf((o) -> o.getTextRange().containsOffset(offset))
            : ParameterInfoUtils.getCurrentParameterIndex(
                argList.getNode(), offset, handler.getActualParameterDelimiterType());

    int prevOrNextParameterIndex =
        isNext && currentParameterIndex < parameters.length - 1
            ? currentParameterIndex + 1
            : !isNext && currentParameterIndex > 0 ? currentParameterIndex - 1 : -1;
    return prevOrNextParameterIndex != -1
        ? parameters[prevOrNextParameterIndex].getTextRange().getStartOffset()
        : -1;
  }
  private static void appendInferredType(
      PsiElement originalElement, GrVariable variable, StringBuilder buffer) {
    PsiType inferredType = null;
    if (PsiImplUtil.isWhiteSpaceOrNls(originalElement)) {
      originalElement = PsiTreeUtil.prevLeaf(originalElement);
    }
    if (originalElement != null
        && originalElement.getNode().getElementType() == GroovyTokenTypes.mIDENT) {
      originalElement = originalElement.getParent();
    }
    if (originalElement instanceof GrReferenceExpression) {
      inferredType = ((GrReferenceExpression) originalElement).getType();
    } else if (originalElement instanceof GrVariableDeclaration) {
      inferredType = variable.getTypeGroovy();
    } else if (originalElement instanceof GrVariable) {
      inferredType = ((GrVariable) originalElement).getTypeGroovy();
    }

    if (inferredType != null) {
      buffer.append("[inferred type] ");
      appendTypeString(buffer, inferredType, originalElement);
    } else {
      buffer.append("[cannot infer type]");
    }
  }
 private void calculateAlignments(List<ASTNode> children, boolean classLevel) {
   List<GrStatement> currentGroup = null;
   boolean spock = true;
   for (ASTNode child : children) {
     PsiElement psi = child.getPsi();
     if (psi instanceof GrLabeledStatement) {
       alignGroup(currentGroup, spock, classLevel);
       currentGroup = ContainerUtil.newArrayList((GrStatement) psi);
       spock = true;
     } else if (currentGroup != null && spock && isTablePart(psi)) {
       currentGroup.add((GrStatement) psi);
     } else if (psi instanceof GrVariableDeclaration) {
       GrVariable[] variables = ((GrVariableDeclaration) psi).getVariables();
       if (variables.length > 0) {
         if (!classLevel || currentGroup == null || fieldGroupEnded(psi) || spock) {
           alignGroup(currentGroup, spock, classLevel);
           currentGroup = ContainerUtil.newArrayList();
           spock = false;
         }
         currentGroup.add((GrStatement) psi);
       }
     } else {
       if (psi instanceof PsiComment) {
         PsiElement prev = psi.getPrevSibling();
         if (prev != null && prev.getNode().getElementType() != mNLS
             || classLevel && !fieldGroupEnded(psi)) {
           continue;
         }
       }
       alignGroup(currentGroup, spock, classLevel);
       currentGroup = null;
     }
   }
 }
  @Override
  public void collect(PsiElement psiElement, @NotNull Collection<LineMarkerInfo> lineMarkerInfos) {
    PsiElement parent = psiElement.getParent();
    IElementType elementType = psiElement.getNode().getElementType();
    if ((elementType == CSharpTokens.IDENTIFIER || elementType == CSharpTokens.THIS_KEYWORD)
        && OverrideUtil.isAllowForOverride(parent)) {
      DotNetVirtualImplementOwner virtualImplementOwner = (DotNetVirtualImplementOwner) parent;

      Collection<DotNetVirtualImplementOwner> overrideElements =
          OverrideUtil.collectOverridenMembers(virtualImplementOwner);

      if (overrideElements.isEmpty()) {
        return;
      }

      Icon icon = CSharpIcons.Gutter.HidedMethod;
      for (DotNetVirtualImplementOwner overrideElement : overrideElements) {
        if (overrideElement.getTypeForImplement() == null) {
          icon = null;
          break;
        }
      }

      if (icon == null) {
        boolean allAbstract = true;
        for (DotNetVirtualImplementOwner overrideElement : overrideElements) {
          if (!(overrideElement instanceof DotNetModifierListOwner
              && ((DotNetModifierListOwner) overrideElement)
                  .hasModifier(DotNetModifier.ABSTRACT))) {
            allAbstract = false;
            break;
          }
        }

        boolean abstractMe =
            virtualImplementOwner instanceof DotNetModifierListOwner
                && ((DotNetModifierListOwner) virtualImplementOwner)
                    .hasModifier(DotNetModifier.ABSTRACT);

        if (allAbstract && abstractMe) {
          icon = AllIcons.Gutter.OverridenMethod;
        } else if (abstractMe) {
          icon = AllIcons.Gutter.ImplementedMethod;
        } else {
          icon = AllIcons.Gutter.OverridenMethod;
        }
      }
      val lineMarkerInfo =
          new LineMarkerInfo<PsiElement>(
              psiElement,
              psiElement.getTextRange(),
              icon,
              Pass.UPDATE_OVERRIDEN_MARKERS,
              new ConstantFunction<PsiElement, String>("Searching for overrided"),
              OurHandler.INSTANCE,
              GutterIconRenderer.Alignment.LEFT);

      lineMarkerInfos.add(lineMarkerInfo);
    }
  }
Esempio n. 21
0
  @NotNull
  private static String getMultilineDocCommentText(final @NotNull DartDocComment docComment) {
    final StringBuilder buf = new StringBuilder();
    boolean afterAsterisk = false;

    for (PsiElement child = docComment.getFirstChild();
        child != null;
        child = child.getNextSibling()) {
      final IElementType elementType = child.getNode().getElementType();
      final String text = child.getText();

      if (elementType != DartTokenTypesSets.MULTI_LINE_DOC_COMMENT_START
          && elementType != DartTokenTypesSets.DOC_COMMENT_LEADING_ASTERISK
          && elementType != DartTokenTypesSets.MULTI_LINE_COMMENT_END) {
        int newLinesCount;
        if (child instanceof PsiWhiteSpace
            && (newLinesCount = StringUtil.countNewLines(text)) > 0) {
          buf.append(StringUtil.repeatSymbol('\n', newLinesCount));
        } else {
          if (afterAsterisk && text.startsWith(" ")) {
            buf.append(text.substring(1));
          } else {
            buf.append(text);
          }
        }
      }

      afterAsterisk = elementType == DartTokenTypesSets.DOC_COMMENT_LEADING_ASTERISK;
    }

    return buf.toString();
  }
 @NotNull
 public IElementType getOperationTokenType() {
   PsiElement opElement = getOperationToken();
   ASTNode node = opElement.getNode();
   assert node != null;
   return node.getElementType();
 }
  public static PsiElement findTailingSemicolon(@NotNull GrStatement statement) {
    final PsiElement nextNonSpace = PsiUtil.skipWhitespaces(statement.getNextSibling(), true);
    if (nextNonSpace != null && nextNonSpace.getNode().getElementType() == mSEMI) {
      return nextNonSpace;
    }

    return null;
  }
Esempio n. 24
0
 public static void changeModifier(
     PsiElement element,
     @Nullable JetModifierList modifierList,
     @Nullable PsiElement insertAnchor,
     JetToken[] modifiersThatCanBeReplaced,
     Project project,
     boolean toBeginning,
     JetModifierList listWithModifier) {
   PsiElement whiteSpace = JetPsiFactory.createWhiteSpace(project);
   if (modifierList == null) {
     if (listWithModifier != null) {
       if (insertAnchor != null) {
         listWithModifier = (JetModifierList) element.addBefore(listWithModifier, insertAnchor);
         element.addBefore(whiteSpace, insertAnchor);
         element.addBefore(whiteSpace, listWithModifier);
       } else {
         PsiElement firstChild = element.getFirstChild();
         element.addBefore(listWithModifier, firstChild);
         element.addBefore(whiteSpace, firstChild);
       }
     }
   } else {
     boolean replaced = false;
     if (modifiersThatCanBeReplaced != null) {
       PsiElement toBeReplaced = null;
       PsiElement toReplace = null;
       for (JetToken modifierThatCanBeReplaced : modifiersThatCanBeReplaced) {
         if (modifierList.hasModifier(modifierThatCanBeReplaced)) {
           PsiElement modifierElement =
               modifierList.getModifierNode(modifierThatCanBeReplaced).getPsi();
           assert modifierElement != null;
           if (!replaced && listWithModifier != null) {
             toBeReplaced = modifierElement;
             toReplace = listWithModifier.getFirstChild();
             // modifierElement.replace(listWithModifier.getFirstChild());
             replaced = true;
           } else {
             modifierList.deleteChildInternal(modifierElement.getNode());
           }
         }
       }
       if (toBeReplaced != null && toReplace != null) {
         toBeReplaced.replace(toReplace);
       }
     }
     if (!replaced && listWithModifier != null) {
       if (toBeginning) {
         PsiElement firstChild = modifierList.getFirstChild();
         modifierList.addBefore(listWithModifier.getFirstChild(), firstChild);
         modifierList.addBefore(whiteSpace, firstChild);
       } else {
         PsiElement lastChild = modifierList.getLastChild();
         modifierList.addAfter(listWithModifier.getFirstChild(), lastChild);
         modifierList.addAfter(whiteSpace, lastChild);
       }
     }
   }
 }
Esempio n. 25
0
 @Nullable
 public static PsiElement prevLeafIgnoringWhitespaceAndComments(@NotNull PsiElement element) {
   PsiElement prev = PsiTreeUtil.prevLeaf(element, true);
   while (prev != null
       && KtTokens.WHITE_SPACE_OR_COMMENT_BIT_SET.contains(prev.getNode().getElementType())) {
     prev = PsiTreeUtil.prevLeaf(prev, true);
   }
   return prev;
 }
 private static boolean isTagStartOrEnd(@Nullable PsiElement element) {
   if (element == null) return false;
   final IElementType type = element.getNode().getElementType();
   if (type == XmlTokenType.XML_NAME)
     return isTagStartOrEnd(element.getNextSibling()) || isTagStartOrEnd(element.getPrevSibling());
   return type == XmlTokenType.XML_START_TAG_START
       || type == XmlTokenType.XML_END_TAG_START
       || type == XmlTokenType.XML_TAG_END;
 }
Esempio n. 27
0
  @Nullable
  private static LineRange getWhenEntryTargetRange(
      @NotNull Editor editor, @NotNull PsiElement sibling, boolean down) {
    if (sibling.getNode().getElementType() == (down ? JetTokens.RBRACE : JetTokens.LBRACE)
        && PsiTreeUtil.getParentOfType(sibling, JetWhenEntry.class) == null) {
      return null;
    }

    return new LineRange(sibling, sibling, editor.getDocument());
  }
Esempio n. 28
0
 @Override
 public PsiElement qualifyClassReferences(@NotNull PsiElement element) {
   final ReferenceAdjuster adjuster =
       ReferenceAdjuster.Extension.getReferenceAdjuster(element.getLanguage());
   if (adjuster != null) {
     final ASTNode reference = adjuster.process(element.getNode(), false, false, true, true);
     return SourceTreeToPsiMap.treeToPsiNotNull(reference);
   }
   return element;
 }
Esempio n. 29
0
 public static ASTNode createNameIdentifier(Project project, String name)
     throws IncorrectOperationException {
   final PsiFile dummyFile =
       PsiFileFactory.getInstance(project)
           .createFileFromText(
               DUMMY + ParserFileType.PARSER_FILE_TYPE.getDefaultExtension(), name);
   final PsiElement expressionStatement = dummyFile.getFirstChild();
   assert expressionStatement != null;
   return expressionStatement.getNode();
 }
Esempio n. 30
0
 public void checkParameterHasNoValOrVar(
     @NotNull JetParameter parameter,
     @NotNull DiagnosticFactory1<PsiElement, JetKeywordToken> diagnosticFactory) {
   PsiElement valOrVar = parameter.getValOrVarKeyword();
   if (valOrVar != null) {
     trace.report(
         diagnosticFactory.on(
             valOrVar, ((JetKeywordToken) valOrVar.getNode().getElementType())));
   }
 }