Why is it that a Java String ending with "." cannot enter the getVariants method in Reference?

/**
 * Returns the array of String, {@link PsiElement} and/or {@link LookupElement}
 * instances representing all identifiers that are visible at the location of the reference. The contents
 * of the returned array are used to build the lookup list for basic code completion. (The list
 * of visible identifiers may not be filtered by the completion prefix string - the
 * filtering is performed later by the IDE.)
 * <p>
 * This method is default since 2018.3.
 *
 * @return the array of available identifiers.
 */
@Override
public Object @NotNull [] getVariants() {
    if (StringUtils.isNotBlank(rqlxKey) && rqlxKey.contains(".")) {
        Module module = ModuleUtil.findModuleForPsiElement(myElement);
        if (module == null) {
            return super.getVariants();
        }
        String beforeRqlxKey = StringUtils.substringBeforeLast(rqlxKey, CompletionUtil.DUMMY_IDENTIFIER);
        String prefixKey = StringUtils.substringBeforeLast(beforeRqlxKey, ".");
        Optional<PsiPackage> aPackage = SnowJavaUtils.findPackage(module.getProject(), prefixKey);
        List<PsiFile> rqlxFiles = RqlxUtils.findFilesByPath(prefixKey, module.getModuleScope());
        ArrayList<SnowLookUpElement> appendElement = new ArrayList<>();
        if (aPackage.isPresent()) {
            PsiPackage psiPackage = aPackage.get();
            PsiPackage[] subPackages = psiPackage.getSubPackages(module.getModuleScope());
            PsiFile[] files = psiPackage.getFiles(module.getModuleScope());
            for (PsiPackage subPackage : subPackages) {
                appendElement.add(new SnowLookUpElement(subPackage.getName(), subPackage));
            }
            for (PsiFile file : files) {
                if (RqlxUtils.isRqlxFile(file)) {
                    appendElement.add(new SnowLookUpElement(FilenameUtils.getBaseName(file.getName()), file));
                }
            }

        }

        if (CollectionUtils.isNotEmpty(rqlxFiles)) {
            DomManager domManager = DomManager.getDomManager(module.getProject());
            for (PsiFile file : rqlxFiles) {
                XmlFile xmlFile = (XmlFile) file;
                DomFileElement<Mapper> mapperDomFileElement = domManager.getFileElement(xmlFile, Mapper.class);
                if (mapperDomFileElement != null) {
                    Mapper mapper = mapperDomFileElement.getRootElement();
                    List<Rql> rqls = mapper.getRqls();
                    for (Rql rql : rqls) {
                        XmlAttribute xmlAttribute = rql.getId().getXmlAttribute();
                        GenericAttributeValue<String> paramType = rql.getParamType();
                        String resultType = null;
                        if (rql instanceof Select) {
                            Select select = (Select) rql;
                            resultType = select.getResultType().getValue();
                            if (StringUtils.isNotBlank(resultType)) {
                                resultType = StringUtils.substringAfterLast(resultType, ".");
                            }
                        }
                        if (xmlAttribute != null) {
                            appendElement.add(
                                new SnowLookUpElement(xmlAttribute.getValue(), xmlAttribute, paramType.getValue(),
                                    resultType));
                        }
                    }
                }
            }
        }
        String s = StringUtils.substringBeforeLast(myElement.getText(), CompletionUtil.DUMMY_IDENTIFIER);
        String text = StringUtils.removeQuot(s);
        ArrayList<LookupElement> result = new ArrayList<>();
        if (text.contains(".")) {
            String prefix = StringUtils.substringBeforeLast(text, ".");
            for (SnowLookUpElement snowLookUpElement : appendElement) {
                snowLookUpElement.setLookUpText(prefix + "." + snowLookUpElement.getLookupString());
                result.add(snowLookUpElement);
            }
        } else {
            result.addAll(appendElement);
        }
        return result.toArray();
    }
    return super.getVariants();
}

<completion.confidence language="JAVA"
        implementationClass="com.ruimin.helper.java.contributor.SnowLiteralCompletionConfidence"
        order="before javaSkipAutopopupInStrings"/>

@NotNull
@Override
public ThreeState shouldSkipAutopopup(@NotNull PsiElement contextElement, @NotNull PsiFile psiFile, int offset) {
    if (isInStringLiteral(contextElement)) {
        PsiLiteralExpression expression;
        if (contextElement instanceof PsiJavaToken) {
            expression = (PsiLiteralExpression) contextElement.getParent();
        } else if (contextElement instanceof PsiLiteralExpression) {
            expression = (PsiLiteralExpression) contextElement;
        } else if (contextElement instanceof PsiLiteral) {
            expression = (PsiLiteralExpression) contextElement.getParent();
        } else {
            return ThreeState.YES;
        }
        PsiMethodCallExpression callExpression = RqlxUtils.getLatestMethodCallExpressionFromParent(expression);
        if (callExpression != null) {
            PsiElement referenceExpression = callExpression.getFirstChild();
            if (RqlxUtils.isRqlxMethodName(referenceExpression.getText()) || RqlxUtils.isSpliceRqlxKey(
                referenceExpression)) {
                return ThreeState.NO;
            }
        }
        return ThreeState.YES;
    }
    return ThreeState.UNSURE;
}

public static boolean isInStringLiteral(PsiElement element) {
    ParserDefinition definition = LanguageParserDefinitions.INSTANCE.forLanguage(
        PsiUtilCore.findLanguageFromElement(element));
    return definition != null && (isStringLiteral(element, definition) || isStringLiteral(element.getParent(),
        definition));
}

private static boolean isStringLiteral(PsiElement element, ParserDefinition definition) {
    return PlatformPatterns.psiElement().withElementType(definition.getStringLiteralElements()).accepts(element);
}