import com.intellij.spellchecker.tokenizer.Tokenizer; //导入依赖的package包/类
@NotNull
@Override
public Tokenizer getTokenizer(PsiElement element) {
  if (element instanceof PsiMethod) {
    return myMethodNameTokenizer;
  }
  if (element instanceof PsiDocComment) {
    return myDocCommentTokenizer;
  }
  if (element instanceof PsiLiteralExpression) {
    if (SuppressManager.isSuppressedInspectionName((PsiLiteralExpression)element)) {
      return EMPTY_TOKENIZER;
    }
    return myLiteralExpressionTokenizer;
  }
  if (element instanceof PsiNamedElement) {
    return myNamedElementTokenizer;
  }

  return super.getTokenizer(element);
}
 

import com.intellij.spellchecker.tokenizer.Tokenizer; //导入依赖的package包/类
@NotNull
@Override
public Tokenizer getTokenizer(PsiElement element) {
  // Only allow print and println strings to be tokenized. We don't want to flag
  // strings in Gradle files that are not under the user's control: names of
  // dependencies, names of plugins, names of class path elements, etc. Turns
  // out there are a lot of different forms of these, so rather than trying to
  // blacklist all the types of strings we don't want to spell check, instead we
  // simply whitelist "print" and "println":
  if (TokenSets.STRING_LITERAL_SET.contains(element.getNode().getElementType()) &&
      !isPrint(element)) {
    // If this element references some external name, such as a dependency or an
    // application package, there is no point in flagging it since the user can't
    // change it
    return EMPTY_TOKENIZER;
  }

  return super.getTokenizer(element);
}
 

import com.intellij.spellchecker.tokenizer.Tokenizer; //导入依赖的package包/类
@NotNull
@Override
public Tokenizer getTokenizer(PsiElement element) {
  if (TokenSets.STRING_LITERAL_SET.contains(element.getNode().getElementType())) {
    return myStringTokenizer;
  }
  if (element instanceof GrNamedElement) {
    final PsiElement name = ((GrNamedElement)element).getNameIdentifierGroovy();
    if (TokenSets.STRING_LITERAL_SET.contains(name.getNode().getElementType())) {
      return EMPTY_TOKENIZER;
    }
  }
  if (element instanceof PsiDocComment) return myDocCommentTokenizer;
  //if (element instanceof GrLiteralImpl && ((GrLiteralImpl)element).isStringLiteral()) return myStringTokenizer;
  return super.getTokenizer(element);
}
 

import com.intellij.spellchecker.tokenizer.Tokenizer; //导入依赖的package包/类
@NotNull
@Override
public Tokenizer getTokenizer(PsiElement element) {
    if (element instanceof PsiWhiteSpace) {
        return EMPTY_TOKENIZER;
    }
    if (element instanceof PsiNameIdentifierOwner) {
        return new PsiIdentifierOwnerTokenizer();
    }
    if (element.getParent() instanceof PsiNameIdentifierOwner) {
        return EMPTY_TOKENIZER;
    }
    if (element.getNode().getElementType() == JSGraphQLEndpointTokenTypes.IDENTIFIER) {
        return IDENTIFIER_TOKENIZER;
    }
    if (element instanceof PsiComment) {
        if (SuppressionUtil.isSuppressionComment(element)) {
            return EMPTY_TOKENIZER;
        }
        return myCommentTokenizer;
    }
    return EMPTY_TOKENIZER;
}
 

import com.intellij.spellchecker.tokenizer.Tokenizer; //导入依赖的package包/类
@NotNull
@Override
public Tokenizer getTokenizer(PsiElement element) {

    if(!(element instanceof StringLiteralExpression)) {
        return super.getTokenizer(element);
    }

    if(!ProjectComponent.isEnabled(element.getProject())) {
        return super.getTokenizer(element);
    }

    Container container = Utils.findContainerForPimpleArrayAccessLiteral((StringLiteralExpression) element);
    if (container == null) {

        container = Utils.findContainerForFirstParameterOfPimpleMethod((StringLiteralExpression) element);
        if (container == null) {
            return super.getTokenizer(element);
        }
    }

    return DUMMY_TOKENIZER;
}
 

import com.intellij.spellchecker.tokenizer.Tokenizer; //导入依赖的package包/类
@NotNull
@Override
public Tokenizer getTokenizer(PsiElement element) {
  if (element instanceof JsonStringLiteral) {
    return ourStringLiteralTokenizer;
  }
  return super.getTokenizer(element);
}
 

import com.intellij.spellchecker.tokenizer.Tokenizer; //导入依赖的package包/类
@NotNull
@Override
public Tokenizer getTokenizer(PsiElement element) {
  IElementType elementType = element.getNode().getElementType();
  if (elementType == RestTokenTypes.FIELD ||
      elementType == RestTokenTypes.CUSTOM_DIRECTIVE ||
      elementType == RestTokenTypes.REST_DJANGO_INJECTION ||
      elementType == RestTokenTypes.REST_INJECTION) {
    return EMPTY_TOKENIZER;
  }
  if (element instanceof LeafPsiElement && element.getLanguage() == RestLanguage.INSTANCE) {
    return REST_ELEMENT_TOKENIZER;
  }
  return EMPTY_TOKENIZER;
}
 

import com.intellij.spellchecker.tokenizer.Tokenizer; //导入依赖的package包/类
@NotNull
@Override
public Tokenizer getTokenizer(PsiElement element) {
  if (element instanceof PyStringLiteralExpression) {
    PsiElement parent = element.getParent();
    if (parent instanceof PyBinaryExpression) {
      PyBinaryExpression binaryExpression = (PyBinaryExpression)parent;
      if (element == binaryExpression.getLeftExpression() && binaryExpression.getOperator() == PyTokenTypes.PERC) {
        return myFormatStringTokenizer;
      }
    }
    return myStringLiteralTokenizer;
  }
  return super.getTokenizer(element);
}
 

import com.intellij.spellchecker.tokenizer.Tokenizer; //导入依赖的package包/类
@NotNull
@Override
public Tokenizer getTokenizer(PsiElement element) {
  if (isAttributeValueContext(element)) {
    return getAttributeValueTokenizer(element);
  }

  if (inEnglish(element)) {
    return super.getTokenizer(element);
  }

  return EMPTY_TOKENIZER;
}
 

import com.intellij.spellchecker.tokenizer.Tokenizer; //导入依赖的package包/类
@NotNull
public Tokenizer getAttributeValueTokenizer(PsiElement element) {
  assert element instanceof XmlAttributeValue;

  if (AndroidResourceUtil.isIdDeclaration((XmlAttributeValue)element)) {
    return myAttributeValueRenamingTokenizer;
  }
  final PsiElement parent = element.getParent();

  if (parent instanceof XmlAttribute) {
    final String value = ((XmlAttribute)parent).getValue();

    if (value != null) {
      final GenericAttributeValue domValue = DomManager.getDomManager(
        parent.getProject()).getDomElement((XmlAttribute)parent);

      if (domValue != null) {
        final Converter converter = domValue.getConverter();

        if (converter instanceof ResourceReferenceConverter) {
          return myResourceReferenceTokenizer;
        }
        else if (converter instanceof ConstantFieldConverter) {
          return EMPTY_TOKENIZER;
        }
        else if (converter instanceof ResourceNameConverter || converter instanceof AndroidPackageConverter) {
          return myAttributeValueRenamingTokenizer;
        }
      }
    }
  }
  return super.getTokenizer(element);
}
 

import com.intellij.spellchecker.tokenizer.Tokenizer; //导入依赖的package包/类
@NotNull
@Override
public Tokenizer getTokenizer(PsiElement element) {
  if (element instanceof PropertyValueImpl) {
    return myPropertyValueTokenizer;
  }
  if (element instanceof PropertyKeyImpl) {
    return myPropertyTokenizer;
  }
  return super.getTokenizer(element);
}
 

import com.intellij.spellchecker.tokenizer.Tokenizer; //导入依赖的package包/类
@NotNull
@Override
public Tokenizer getTokenizer(PsiElement element) {
    IElementType elementType = element.getNode().getElementType();

    if (elementType instanceof MultiMarkdownTokenType || elementType instanceof MultiMarkdownElementType) {
        if (NO_SPELL_CHECK_SET.contains(elementType)) {
            //logger.info("empty tokenizer for " + element.toString());
            return EMPTY_TOKENIZER;
        }

        // here we can return custom tokenizers if needed
        //logger.info("text tokenizer for " + element.toString());
        if (element instanceof MultiMarkdownNamedElement) {
            //logger.info("identifier tokenizer for " + element.toString());
            return IDENTIFIER_TOKENIZER;
        }

        // this is to prevent two spelling errors for every occurence but these are rename and change to so we'll keep them
        //if (NO_SPELL_LEAF_SET.contains(elementType)) {
        //    return EMPTY_TOKENIZER;
        //}

        return TEXT_TOKENIZER;
    }
    return super.getTokenizer(element);
}
 

import com.intellij.spellchecker.tokenizer.Tokenizer; //导入依赖的package包/类
/**
 * Provides {@link #TEXT_TOKENIZER} for {@link LatexText} elements.
 *
 * @param element to check
 * @return {@link #TEXT_TOKENIZER} for {@link LatexText} or {@link #EMPTY_TOKENIZER}.
 */
@NotNull
@Override
public Tokenizer getTokenizer(PsiElement element) {
    if (element instanceof LatexText) {
        return TEXT_TOKENIZER;
    }
    return EMPTY_TOKENIZER;
}
 

import com.intellij.spellchecker.tokenizer.Tokenizer; //导入依赖的package包/类
@NotNull
@Override
public Tokenizer getTokenizer(PsiElement element) {
  if (element instanceof PropertyValueImpl) {
    return myPropertyValueTokenizer;
  }
  if (element instanceof PropertyImpl) {
    return myPropertyTokenizer;
  }
  return super.getTokenizer(element);
}
 

import com.intellij.spellchecker.tokenizer.Tokenizer; //导入依赖的package包/类
@NotNull
@Override
public Tokenizer getTokenizer(PsiElement element)
{
	if(element instanceof PsiNameIdentifierOwner)
	{
		return ourNameTokenizer;
	}
	return super.getTokenizer(element);
}
 

import com.intellij.spellchecker.tokenizer.Tokenizer; //导入依赖的package包/类
@NotNull
@Override
public Tokenizer getTokenizer(PsiElement element) {
  IElementType elementType = element.getNode().getElementType();
  if (elementType == AsciiDocTokenTypes.HEADING || elementType == AsciiDocTokenTypes.TEXT) {
    return TEXT_TOKENIZER;
  }
  return EMPTY_TOKENIZER;
}
 

import com.intellij.spellchecker.tokenizer.Tokenizer; //导入依赖的package包/类
@NotNull
@Override
public Tokenizer getTokenizer(PsiElement element) {
  return EMPTY_TOKENIZER;
}