| /* |
| * Copyright 2006 Sascha Weinreuter |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.intellij.lang.regexp.validation; |
| |
| import com.intellij.codeInsight.intention.IntentionAction; |
| import com.intellij.codeInspection.ProblemHighlightType; |
| import com.intellij.lang.ASTNode; |
| import com.intellij.lang.annotation.Annotation; |
| import com.intellij.lang.annotation.AnnotationHolder; |
| import com.intellij.lang.annotation.Annotator; |
| import com.intellij.psi.PsiComment; |
| import com.intellij.psi.PsiElement; |
| import com.intellij.psi.util.PsiTreeUtil; |
| import org.intellij.lang.regexp.*; |
| import org.intellij.lang.regexp.psi.*; |
| import org.jetbrains.annotations.NotNull; |
| |
| import java.math.BigInteger; |
| |
| public final class RegExpAnnotator extends RegExpElementVisitor implements Annotator { |
| private AnnotationHolder myHolder; |
| private final RegExpLanguageHosts myLanguageHosts; |
| |
| public RegExpAnnotator() { |
| myLanguageHosts = RegExpLanguageHosts.getInstance(); |
| } |
| |
| public void annotate(@NotNull PsiElement psiElement, @NotNull AnnotationHolder holder) { |
| assert myHolder == null : "unsupported concurrent annotator invocation"; |
| try { |
| myHolder = holder; |
| psiElement.accept(this); |
| } |
| finally { |
| myHolder = null; |
| } |
| } |
| |
| public void visitRegExpCharRange(RegExpCharRange range) { |
| final RegExpCharRange.Endpoint from = range.getFrom(); |
| final RegExpCharRange.Endpoint to = range.getTo(); |
| final boolean a = from instanceof RegExpChar; |
| final boolean b = to instanceof RegExpChar; |
| if (a && b) { |
| final Character t = ((RegExpChar)to).getValue(); |
| final Character f = ((RegExpChar)from).getValue(); |
| if (t != null && f != null) { |
| if (t < f) { |
| myHolder.createErrorAnnotation(range, "Illegal character range (to < from)"); |
| } |
| else if (t == f) { |
| myHolder.createWarningAnnotation(range, "Redundant character range"); |
| } |
| } |
| } |
| else if (a != b) { |
| myHolder.createErrorAnnotation(range, "Character class (e.g. '\\\\w') may not be used inside character range"); |
| } |
| else if (from.getText().equals(to.getText())) { |
| myHolder.createWarningAnnotation(range, "Redundant character range"); |
| } |
| } |
| |
| public void visitRegExpChar(final RegExpChar ch) { |
| final Character value = ch.getValue(); |
| if (value == null) { |
| switch (ch.getType()) { |
| case CHAR: |
| myHolder.createErrorAnnotation(ch, "Illegal/unsupported escape sequence"); |
| break; |
| case HEX: |
| myHolder.createErrorAnnotation(ch, "Illegal hexadecimal escape sequence"); |
| break; |
| case OCT: |
| myHolder.createErrorAnnotation(ch, "Illegal octal escape sequence"); |
| break; |
| case UNICODE: |
| myHolder.createErrorAnnotation(ch, "Illegal unicode escape sequence"); |
| break; |
| case INVALID: |
| // produces a parser error. already handled by IDEA and possibly suppressed by IntelliLang |
| break; |
| } |
| } |
| else { |
| final String text = ch.getUnescapedText(); |
| if (text.startsWith("\\") && myLanguageHosts.isRedundantEscape(ch, text)) { |
| final ASTNode astNode = ch.getNode().getFirstChildNode(); |
| if (astNode != null && astNode.getElementType() == RegExpTT.REDUNDANT_ESCAPE) { |
| final Annotation a = myHolder.createWeakWarningAnnotation(ch, "Redundant character escape"); |
| registerFix(a, new RemoveRedundantEscapeAction(ch)); |
| } |
| } |
| } |
| } |
| |
| public void visitRegExpProperty(RegExpProperty property) { |
| final ASTNode category = property.getCategoryNode(); |
| if (category == null) { |
| return; |
| } |
| if(!myLanguageHosts.isValidCategory(category.getPsi(), category.getText())) { |
| final Annotation a = myHolder.createErrorAnnotation(category, "Unknown character category"); |
| if (a != null) { |
| // IDEA-9381 |
| a.setHighlightType(ProblemHighlightType.LIKE_UNKNOWN_SYMBOL); |
| } |
| } |
| } |
| |
| public void visitRegExpBackref(final RegExpBackref backref) { |
| final RegExpGroup group = backref.resolve(); |
| if (group == null) { |
| final Annotation a = myHolder.createErrorAnnotation(backref, "Unresolved backreference"); |
| if (a != null) { |
| // IDEA-9381 |
| a.setHighlightType(ProblemHighlightType.LIKE_UNKNOWN_SYMBOL); |
| } |
| } |
| else if (PsiTreeUtil.isAncestor(group, backref, true)) { |
| myHolder.createWarningAnnotation(backref, "Backreference is nested into the capturing group it refers to"); |
| } |
| } |
| |
| public void visitRegExpGroup(RegExpGroup group) { |
| final RegExpPattern pattern = group.getPattern(); |
| if (pattern != null) { |
| final RegExpBranch[] branches = pattern.getBranches(); |
| if (isEmpty(branches)) { |
| // catches "()" as well as "(|)" |
| myHolder.createWarningAnnotation(group, "Empty group"); |
| } |
| else if (branches.length == 1) { |
| final RegExpAtom[] atoms = branches[0].getAtoms(); |
| if (atoms.length == 1 && atoms[0] instanceof RegExpGroup) { |
| if (group.isSimple()) { |
| final RegExpGroup innerGroup = (RegExpGroup)atoms[0]; |
| if (group.isCapturing() == innerGroup.isCapturing()) { |
| myHolder.createWarningAnnotation(group, "Redundant group nesting"); |
| } |
| } |
| } |
| } |
| } |
| if (group.isPythonNamedGroup() || group.isRubyNamedGroup()) { |
| if (!myLanguageHosts.supportsNamedGroupSyntax(group)) { |
| myHolder.createErrorAnnotation(group, "This named group syntax is not supported"); |
| } |
| } |
| } |
| |
| @Override |
| public void visitRegExpPyNamedGroupRef(RegExpPyNamedGroupRef groupRef) { |
| /* the named group itself will be highlighted as unsupported; no need to highlight reference as well |
| RegExpLanguageHost host = findRegExpHost(groupRef); |
| if (host == null || !host.supportsPythonNamedGroups()) { |
| myHolder.createErrorAnnotation(groupRef, "This named group reference syntax is not supported"); |
| return; |
| } |
| */ |
| final RegExpGroup group = groupRef.resolve(); |
| if (group == null) { |
| final Annotation a = myHolder.createErrorAnnotation(groupRef, "Unresolved backreference"); |
| if (a != null) { |
| // IDEA-9381 |
| a.setHighlightType(ProblemHighlightType.LIKE_UNKNOWN_SYMBOL); |
| } |
| } |
| else if (PsiTreeUtil.isAncestor(group, groupRef, true)) { |
| myHolder.createWarningAnnotation(groupRef, "Group reference is nested into the named group it refers to"); |
| } |
| } |
| |
| @Override |
| public void visitComment(PsiComment comment) { |
| if (comment.getText().startsWith("(?#")) { |
| if (!myLanguageHosts.supportsPerl5EmbeddedComments(comment)) { |
| myHolder.createErrorAnnotation(comment, "Embedded comments are not supported"); |
| } |
| } |
| } |
| |
| @Override |
| public void visitRegExpPyCondRef(RegExpPyCondRef condRef) { |
| if (!myLanguageHosts.supportsPythonConditionalRefs(condRef)) { |
| myHolder.createErrorAnnotation(condRef, "Conditional references are not supported"); |
| } |
| } |
| |
| private static boolean isEmpty(RegExpBranch[] branches) { |
| for (RegExpBranch branch : branches) { |
| if (branch.getAtoms().length > 0) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| public void visitRegExpQuantifier(RegExpQuantifier quantifier) { |
| final RegExpQuantifier.Count count = quantifier.getCount(); |
| if (!(count instanceof RegExpQuantifier.SimpleCount)) { |
| String min = count.getMin(); |
| String max = count.getMax(); |
| if (max.equals(min)) { |
| if ("1".equals(max)) { // TODO: is this safe when reluctant or possesive modifier is present? |
| final Annotation a = myHolder.createWeakWarningAnnotation(quantifier, "Single repetition"); |
| registerFix(a, new SimplifyQuantifierAction(quantifier, null)); |
| } |
| else { |
| final ASTNode node = quantifier.getNode(); |
| if (node.findChildByType(RegExpTT.COMMA) != null) { |
| final Annotation a = myHolder.createWeakWarningAnnotation(quantifier, "Fixed repetition range"); |
| registerFix(a, new SimplifyQuantifierAction(quantifier, "{" + max + "}")); |
| } |
| } |
| } |
| else if ("0".equals(min) && "1".equals(max)) { |
| final Annotation a = myHolder.createWeakWarningAnnotation(quantifier, "Repetition range replaceable by '?'"); |
| registerFix(a, new SimplifyQuantifierAction(quantifier, "?")); |
| } |
| else if ("0".equals(min) && max.isEmpty()) { |
| final Annotation a = myHolder.createWeakWarningAnnotation(quantifier, "Repetition range replaceable by '*'"); |
| registerFix(a, new SimplifyQuantifierAction(quantifier, "*")); |
| } |
| else if ("1".equals(min) && max.isEmpty()) { |
| final Annotation a = myHolder.createWeakWarningAnnotation(quantifier, "Repetition range replaceable by '+'"); |
| registerFix(a, new SimplifyQuantifierAction(quantifier, "+")); |
| } |
| else if (!min.isEmpty() && !max.isEmpty()) { |
| try { |
| BigInteger minInt = new BigInteger(min); |
| BigInteger maxInt = new BigInteger(max); |
| if (maxInt.compareTo(minInt) < 0) { |
| myHolder.createErrorAnnotation(quantifier, "Illegal repetition range"); |
| } |
| } |
| catch (NumberFormatException ex) { |
| myHolder.createErrorAnnotation(quantifier, "Illegal repetition value"); |
| } |
| } |
| } |
| if (quantifier.getType() == RegExpQuantifier.Type.POSSESSIVE) { |
| if (!myLanguageHosts.supportsPossessiveQuantifiers(quantifier)) { |
| myHolder.createErrorAnnotation(quantifier, "Nested quantifier in regexp"); |
| } |
| } |
| } |
| |
| private static void registerFix(Annotation a, IntentionAction action) { |
| if (a != null) { |
| // IDEA-9381 |
| a.registerFix(action); |
| } |
| } |
| |
| } |
