repo stringlengths 1 191 ⌀ | file stringlengths 23 351 | code stringlengths 0 5.32M | file_length int64 0 5.32M | avg_line_length float64 0 2.9k | max_line_length int64 0 288k | extension_type stringclasses 1 value |
|---|---|---|---|---|---|---|
pmd | pmd-master/pmd-go/src/test/java/net/sourceforge/pmd/cpd/GoTokenizerTest.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.cpd;
import java.util.Properties;
import org.junit.jupiter.api.Test;
import net.sourceforge.pmd.cpd.test.CpdTextComparisonTest;
class GoTokenizerTest extends CpdTextComparisonTest {
GoTokenizerTest() {
super(".go");
}
@Override
public Tokenizer newTokenizer(Properties properties) {
return new GoTokenizer();
}
@Override
protected String getResourcePrefix() {
return "../lang/go/cpd/testdata";
}
@Test
void simpleTest() {
doTest("hello");
}
@Test
void bigFileTest() {
doTest("btrfs");
}
@Test
void testIssue1751() {
doTest("issue-1751");
}
@Test
void testUnicode() {
// https://github.com/pmd/pmd/issues/2752
doTest("sample_unicode");
}
}
| 912 | 16.901961 | 79 | java |
pmd | pmd-master/pmd-go/src/main/java/net/sourceforge/pmd/cpd/GoLanguage.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.cpd;
/**
* @author oinume@gmail.com
*/
public class GoLanguage extends AbstractLanguage {
public GoLanguage() {
super("Go", "go", new GoTokenizer(), ".go");
}
}
| 298 | 17.6875 | 79 | java |
pmd | pmd-master/pmd-go/src/main/java/net/sourceforge/pmd/cpd/GoTokenizer.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.cpd;
import org.antlr.v4.runtime.CharStream;
import org.antlr.v4.runtime.Lexer;
import net.sourceforge.pmd.cpd.impl.AntlrTokenizer;
import net.sourceforge.pmd.lang.go.ast.GolangLexer;
public class GoTokenizer extends AntlrTokenizer {
@Override
protected Lexer getLexerForSource(CharStream charStream) {
return new GolangLexer(charStream);
}
}
| 484 | 23.25 | 79 | java |
pmd | pmd-master/pmd-xml/src/test/java/net/sourceforge/pmd/ant/PMDTaskTest.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.ant;
import org.junit.jupiter.api.Test;
class PMDTaskTest extends AbstractAntTestHelper {
PMDTaskTest() {
super.antTestScriptFilename = "pmdtasktest.xml";
}
@Test
void testXML() {
executeTarget("testXML");
assertOutputContaining("Potentially mistyped CDATA section with extra [ at beginning or ] at the end.");
}
}
| 480 | 21.904762 | 112 | java |
pmd | pmd-master/pmd-xml/src/test/java/net/sourceforge/pmd/lang/xsl/rule/performance/AvoidAxisNavigationTest.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.xsl.rule.performance;
import net.sourceforge.pmd.testframework.PmdRuleTst;
class AvoidAxisNavigationTest extends PmdRuleTst {
// no additional unit tests
}
| 284 | 22.75 | 79 | java |
pmd | pmd-master/pmd-xml/src/test/java/net/sourceforge/pmd/lang/xsl/rule/codestyle/UseConcatOnceTest.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.xsl.rule.codestyle;
import net.sourceforge.pmd.testframework.PmdRuleTst;
class UseConcatOnceTest extends PmdRuleTst {
// no additional unit tests
}
| 276 | 22.083333 | 79 | java |
pmd | pmd-master/pmd-xml/src/test/java/net/sourceforge/pmd/lang/xml/RuleSetFactoryTest.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.xml;
import net.sourceforge.pmd.AbstractRuleSetFactoryTest;
/**
* Test xml's and xslt's rulesets
*/
class RuleSetFactoryTest extends AbstractRuleSetFactoryTest {
// no additional tests yet
}
| 321 | 20.466667 | 79 | java |
pmd | pmd-master/pmd-xml/src/test/java/net/sourceforge/pmd/lang/xml/LanguageVersionTest.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.xml;
import java.util.Arrays;
import java.util.Collection;
import net.sourceforge.pmd.AbstractLanguageVersionTest;
import net.sourceforge.pmd.lang.pom.PomLanguageModule;
import net.sourceforge.pmd.lang.wsdl.WsdlLanguageModule;
import net.sourceforge.pmd.lang.xsl.XslLanguageModule;
class LanguageVersionTest extends AbstractLanguageVersionTest {
static Collection<TestDescriptor> data() {
return Arrays.asList(
new TestDescriptor(XmlLanguageModule.NAME, XmlLanguageModule.TERSE_NAME, "1.1",
getLanguage(XmlLanguageModule.NAME).getDefaultVersion()),
new TestDescriptor(XslLanguageModule.NAME, XslLanguageModule.TERSE_NAME, "3.0",
getLanguage(XslLanguageModule.NAME).getDefaultVersion()),
new TestDescriptor(WsdlLanguageModule.NAME, WsdlLanguageModule.TERSE_NAME, "2.0",
getLanguage(WsdlLanguageModule.NAME).getDefaultVersion()),
new TestDescriptor(PomLanguageModule.NAME, PomLanguageModule.TERSE_NAME, "4.0.0",
getLanguage(PomLanguageModule.NAME).getDefaultVersion()));
}
}
| 1,259 | 42.448276 | 97 | java |
pmd | pmd-master/pmd-xml/src/test/java/net/sourceforge/pmd/lang/xml/XmlParsingHelper.java | /*
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.xml;
import net.sourceforge.pmd.lang.ast.test.BaseParsingHelper;
import net.sourceforge.pmd.lang.pom.PomLanguageModule;
import net.sourceforge.pmd.lang.wsdl.WsdlLanguageModule;
import net.sourceforge.pmd.lang.xml.ast.internal.XmlParserImpl.RootXmlNode;
/**
* @author Clément Fournier
*/
public final class XmlParsingHelper extends BaseParsingHelper<XmlParsingHelper, RootXmlNode> {
public static final XmlParsingHelper XML = new XmlParsingHelper(XmlLanguageModule.NAME, Params.getDefault());
public static final XmlParsingHelper WSDL = new XmlParsingHelper(WsdlLanguageModule.NAME, Params.getDefault());
public static final XmlParsingHelper POM = new XmlParsingHelper(PomLanguageModule.NAME, Params.getDefault());
private XmlParsingHelper(String langName, Params params) {
super(langName, RootXmlNode.class, params);
}
@Override
protected XmlParsingHelper clone(Params params) {
return new XmlParsingHelper(this.getLangName(), params);
}
}
| 1,117 | 35.064516 | 115 | java |
pmd | pmd-master/pmd-xml/src/test/java/net/sourceforge/pmd/lang/xml/ast/XmlParserTest.java | /*
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.xml.ast;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.junit.jupiter.api.Test;
import net.sourceforge.pmd.lang.ast.test.BaseParsingHelper;
import net.sourceforge.pmd.lang.ast.test.BaseTreeDumpTest;
import net.sourceforge.pmd.lang.ast.test.RelevantAttributePrinter;
import net.sourceforge.pmd.lang.xml.XmlParsingHelper;
class XmlParserTest extends BaseTreeDumpTest {
XmlParserTest() {
super(new RelevantAttributePrinter(), ".xml");
}
@Override
public @NonNull BaseParsingHelper<?, ?> getParser() {
return XmlParsingHelper.XML.withResourceContext(getClass(), "testdata");
}
/**
* Verifies the default parsing behavior of the XML parser.
*/
@Test
void testDefaultParsing() {
doTest("sampleXml");
}
@Test
void testNamespaces() {
doTest("sampleNs");
}
@Test
void testBug1518() {
doTest("bug1518");
}
@Test
void dtdIsNotLookedUp() {
// no exception should be thrown
XmlParsingHelper.XML.parse(
"<!DOCTYPE struts-config PUBLIC "
+ " \"-//Apache Software Foundation//DTD Struts Configuration 1.1//EN \" "
+ " \"http://jakarta.inexistinghost.org/struts/dtds/struts-config_1_1.dtd\" >"
+ "<struts-config/>");
}
@Test
void xsdIsNotLookedUp() {
// no exception should be thrown
XmlParsingHelper.XML.parse(
"<?xml version=\"1.0\" encoding=\"UTF-8\"?> "
+ "<web-app xmlns=\"http://java.sun.com/xml/ns/javaee\" "
+ "xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" "
+ "xsi:schemaLocation=\"http://java.sun.com/xml/ns/javaee http://java.inexisting.com/xml/ns/javaee/web-app_2_5.xsd\" "
+ "version=\"2.5\">"
+ "</web-app>");
}
}
| 1,996 | 27.942029 | 134 | java |
pmd | pmd-master/pmd-xml/src/test/java/net/sourceforge/pmd/lang/xml/ast/XmlCoordinatesTest.java | /*
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.xml.ast;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.junit.jupiter.api.Test;
import net.sourceforge.pmd.lang.ast.test.BaseParsingHelper;
import net.sourceforge.pmd.lang.ast.test.BaseTreeDumpTest;
import net.sourceforge.pmd.lang.ast.test.CoordinatesPrinter;
import net.sourceforge.pmd.lang.ast.test.TestUtilsKt;
import net.sourceforge.pmd.lang.xml.XmlParsingHelper;
class XmlCoordinatesTest extends BaseTreeDumpTest {
XmlCoordinatesTest() {
super(CoordinatesPrinter.INSTANCE, ".xml");
}
@Override
public @NonNull BaseParsingHelper<?, ?> getParser() {
return XmlParsingHelper.XML.withResourceContext(getClass(), "testdata");
}
/**
* See bug #1054: XML Rules ever report a line -1 and not the line/column
* where the error occurs
*/
@Test
void testLineNumbers() {
doTest("xmlCoords");
}
@Test
void testAutoclosingElementLength() {
final String xml = "<elementName att1='foo' att2='bar' att3='other' />";
TestUtilsKt.assertPosition(XmlParsingHelper.XML.parse(xml), 1, 1, 1, xml.length());
}
}
| 1,247 | 28.023256 | 91 | java |
pmd | pmd-master/pmd-xml/src/test/java/net/sourceforge/pmd/lang/xml/rule/XmlXPathRuleTest.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.xml.rule;
import static net.sourceforge.pmd.lang.ast.test.TestUtilsKt.assertSize;
import org.junit.jupiter.api.Test;
import net.sourceforge.pmd.Report;
import net.sourceforge.pmd.Rule;
import net.sourceforge.pmd.lang.document.FileId;
import net.sourceforge.pmd.lang.xml.XmlParsingHelper;
class XmlXPathRuleTest {
private static final String A_URI = "http://soap.sforce.com/2006/04/metadata";
private static final String FXML_IMPORTS = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+ "\n"
+ "<!--suppress JavaFxDefaultTag -->\n"
+ "\n"
+ "<?import javafx.scene.layout.AnchorPane?>\n"
+ "<?import javafx.scene.layout.BorderPane?>\n"
+ "<?import javafx.scene.control.Tooltip?>\n"
+ "<?import javafx.scene.control.Label?>\n"
+ "<?import org.kordamp.ikonli.javafx.FontIcon?>\n"
+ "<AnchorPane prefHeight=\"750.0\" prefWidth=\"1200.0\" stylesheets=\"@../css/designer.css\" xmlns=\"http://javafx.com/javafx/8\" xmlns:fx=\"http://javafx.com/fxml/1\">\n"
+ "</AnchorPane>";
final XmlParsingHelper xml = XmlParsingHelper.XML;
private Rule makeXPath(String expression) {
return makeXPath(expression, "");
}
private Rule makeXPath(String expression, String nsUri) {
DomXPathRule rule = new DomXPathRule(expression, nsUri);
rule.setLanguage(xml.getLanguage());
rule.setMessage("XPath Rule Failed");
return rule;
}
@Test
void testFileNameInXpath() {
Report report = xml.executeRule(makeXPath("//b[pmd:fileName() = 'Foo.xml']"),
"<a><b></b></a>",
FileId.fromPathLikeString("src/Foo.xml"));
assertSize(report, 1);
}
@Test
void testTextFunctionInXpath() {
// https://github.com/pmd/pmd/issues/915
Report report = xml.executeRule(makeXPath("//app[text()[1]='app2']"),
"<a><app>app2</app></a>");
assertSize(report, 1);
}
@Test
void testRootNodeWildcardUri() {
// https://github.com/pmd/pmd/issues/3413#issuecomment-1072614398
Report report = xml.executeRule(makeXPath("/*:Flow"),
"<Flow xmlns=\"http://soap.sforce.com/2006/04/metadata\">\n"
+ "</Flow>");
assertSize(report, 1);
}
@Test
void testNoNamespaceRoot() {
Report report = xml.executeRule(makeXPath("/Flow"),
"<Flow>\n"
+ "</Flow>");
assertSize(report, 1);
}
@Test
void testNamespaceDescendantWrongDefaultUri() {
Report report = xml.executeRule(makeXPath("//a"),
"<Flow xmlns='" + A_URI + "'><a/></Flow>");
assertSize(report, 0);
}
@Test
void testNamespaceDescendantOkUri() {
Report report = xml.executeRule(makeXPath("//a", A_URI),
"<Flow xmlns='" + A_URI + "'><a/></Flow>");
assertSize(report, 1);
report = xml.executeRule(makeXPath("//*:a"),
"<Flow xmlns='" + A_URI + "'><a/></Flow>");
assertSize(report, 1);
}
@Test
void testNamespaceDescendantWildcardUri() {
Report report = xml.executeRule(makeXPath("//*:a"),
"<Flow xmlns='" + A_URI + "'><a/></Flow>");
assertSize(report, 1);
}
@Test
void testNamespacePrefixDescendantWildcardUri() {
Report report = xml.executeRule(makeXPath("//*:Flow"),
"<my:Flow xmlns:my='" + A_URI + "'><a/></my:Flow>");
assertSize(report, 1);
}
@Test
void testNamespacePrefixDescendantOkUri() {
Report report = xml.executeRule(makeXPath("//Flow", A_URI),
"<my:Flow xmlns:my='" + A_URI + "'><a/></my:Flow>");
assertSize(report, 1);
}
@Test
void testNamespacePrefixDescendantWrongUri() {
Report report = xml.executeRule(makeXPath("//Flow", "wrongURI"),
"<my:Flow xmlns:my='" + A_URI + "'><a/></my:Flow>");
assertSize(report, 0);
}
@Test
void testRootExpr() {
Report report = xml.executeRule(makeXPath("/"),
"<Flow><a/></Flow>");
assertSize(report, 1);
}
@Test
void testProcessingInstructions() {
Report report = xml.executeRule(makeXPath("/child::processing-instruction()", "http://javafx.com/javafx/8"),
FXML_IMPORTS);
assertSize(report, 5);
}
@Test
void testProcessingInstructionsNamed() {
Report report = xml.executeRule(makeXPath("/child::processing-instruction('import')"),
FXML_IMPORTS);
assertSize(report, 5);
}
@Test
void testProcessingInstructionXML() {
// <?xml ?> does not create a PI
Report report = xml.executeRule(makeXPath("/child::processing-instruction('xml')", "http://javafx.com/javafx/8"),
FXML_IMPORTS);
assertSize(report, 0);
}
@Test
void testComments() {
Report report = xml.executeRule(makeXPath("/child::comment()[fn:starts-with(fn:string(.), 'suppress')]"),
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+ "<!--suppress JavaFxDefaultTag -->\n"
+ "<AnchorPane prefHeight=\"750.0\" prefWidth=\"1200.0\" stylesheets=\"@../css/designer.css\" xmlns=\"http://javafx.com/javafx/8\" xmlns:fx=\"http://javafx.com/fxml/1\">\n"
+ "</AnchorPane>");
assertSize(report, 1);
}
@Test
void testXmlNsFunctions() {
// https://github.com/pmd/pmd/issues/2766
Report report = xml.executeRule(
makeXPath("/manifest[namespace-uri-for-prefix('android', .) = 'http://schemas.android.com/apk/res/android']"),
"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
+ "<manifest xmlns:android=\"http://schemas.android.com/apk/res/android\"\n"
+ " package=\"com.a.b\">\n"
+ "\n"
+ " <application\n"
+ " android:allowBackup=\"true\"\n"
+ " android:icon=\"@mipmap/ic_launcher\"\n"
+ " android:label=\"@string/app_name\"\n"
+ " android:roundIcon=\"@mipmap/ic_launcher_round\"\n"
+ " android:supportsRtl=\"true\"\n"
+ " android:theme=\"@style/AppTheme\">\n"
+ " <activity android:name=\".MainActivity\">\n"
+ " <intent-filter>\n"
+ " <action android:name=\"android.intent.action.MAIN\" />\n"
+ "\n"
+ " <category android:name=\"android.intent.category.LAUNCHER\" />\n"
+ " </intent-filter>\n"
+ " </activity>\n"
+ " </application>\n"
+ "\n"
+ "</manifest>");
assertSize(report, 1);
}
@Test
void testLocationFuns() {
Rule rule = makeXPath("//Flow[pmd:startLine(.) != pmd:endLine(.)]");
Report report = xml.executeRule(rule, "<Flow><a/></Flow>");
assertSize(report, 0);
report = xml.executeRule(rule, "<Flow>\n<a/>\n</Flow>");
assertSize(report, 1);
}
}
| 8,256 | 36.876147 | 219 | java |
pmd | pmd-master/pmd-xml/src/test/java/net/sourceforge/pmd/lang/xml/rule/errorprone/MistypedCDATASectionTest.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.xml.rule.errorprone;
import net.sourceforge.pmd.testframework.PmdRuleTst;
class MistypedCDATASectionTest extends PmdRuleTst {
// no additional unit tests
}
| 284 | 22.75 | 79 | java |
pmd | pmd-master/pmd-xml/src/test/java/net/sourceforge/pmd/lang/pom/rule/errorprone/ProjectVersionAsDependencyVersionTest.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.pom.rule.errorprone;
import net.sourceforge.pmd.testframework.PmdRuleTst;
class ProjectVersionAsDependencyVersionTest extends PmdRuleTst {
// no additional unit tests
}
| 297 | 23.833333 | 79 | java |
pmd | pmd-master/pmd-xml/src/test/java/net/sourceforge/pmd/lang/pom/rule/errorprone/InvalidDependencyTypesTest.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.pom.rule.errorprone;
import net.sourceforge.pmd.testframework.PmdRuleTst;
class InvalidDependencyTypesTest extends PmdRuleTst {
// no additional unit tests
}
| 286 | 22.916667 | 79 | java |
pmd | pmd-master/pmd-xml/src/test/java/net/sourceforge/pmd/xml/cpd/XmlCPDTokenizerTest.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.xml.cpd;
import java.util.Properties;
import org.junit.jupiter.api.Test;
import net.sourceforge.pmd.cpd.Tokenizer;
import net.sourceforge.pmd.cpd.test.CpdTextComparisonTest;
class XmlCPDTokenizerTest extends CpdTextComparisonTest {
XmlCPDTokenizerTest() {
super(".xml");
}
@Override
public Tokenizer newTokenizer(Properties properties) {
return new XmlTokenizer();
}
@Test
void tokenizeTest() {
doTest("simple");
}
}
| 597 | 18.933333 | 79 | java |
pmd | pmd-master/pmd-xml/src/main/java/net/sourceforge/pmd/lang/xsl/XslLanguageModule.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.xsl;
import net.sourceforge.pmd.lang.impl.SimpleLanguageModuleBase;
import net.sourceforge.pmd.lang.xml.XmlHandler;
/**
* Created by christoferdutz on 20.09.14.
*/
public class XslLanguageModule extends SimpleLanguageModuleBase {
public static final String NAME = "XSL";
public static final String TERSE_NAME = "xsl";
public XslLanguageModule() {
super(LanguageMetadata.withId(TERSE_NAME).name(NAME)
.extensions("xsl", "xslt")
.addVersion("1.0")
.addVersion("2.0")
.addDefaultVersion("3.0"),
new XmlHandler());
}
}
| 804 | 27.75 | 79 | java |
pmd | pmd-master/pmd-xml/src/main/java/net/sourceforge/pmd/lang/wsdl/WsdlLanguageModule.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.wsdl;
import net.sourceforge.pmd.lang.impl.SimpleLanguageModuleBase;
import net.sourceforge.pmd.lang.xml.XmlHandler;
/**
* Created by bernardo-macedo on 24.06.15.
*/
public class WsdlLanguageModule extends SimpleLanguageModuleBase {
public static final String NAME = "WSDL";
public static final String TERSE_NAME = "wsdl";
public WsdlLanguageModule() {
super(LanguageMetadata.withId(TERSE_NAME).name(NAME)
.extensions("wsdl")
.addVersion("1.1")
.addDefaultVersion("2.0"),
new XmlHandler());
}
}
| 753 | 28 | 79 | java |
pmd | pmd-master/pmd-xml/src/main/java/net/sourceforge/pmd/lang/xml/XmlHandler.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.xml;
import net.sourceforge.pmd.lang.AbstractPmdLanguageVersionHandler;
import net.sourceforge.pmd.lang.ast.Parser;
/**
* Implementation of LanguageVersionHandler for the XML.
*/
public class XmlHandler extends AbstractPmdLanguageVersionHandler {
@Override
public Parser getParser() {
return new XmlParser();
}
}
| 461 | 21 | 79 | java |
pmd | pmd-master/pmd-xml/src/main/java/net/sourceforge/pmd/lang/xml/XmlParser.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.xml;
import net.sourceforge.pmd.lang.ast.ParseException;
import net.sourceforge.pmd.lang.ast.Parser;
import net.sourceforge.pmd.lang.xml.ast.internal.XmlParserImpl;
import net.sourceforge.pmd.lang.xml.ast.internal.XmlParserImpl.RootXmlNode;
/**
* Adapter for the XmlParser.
*/
public class XmlParser implements Parser {
@Override
public RootXmlNode parse(ParserTask task) throws ParseException {
return new XmlParserImpl().parse(task);
}
}
| 588 | 24.608696 | 79 | java |
pmd | pmd-master/pmd-xml/src/main/java/net/sourceforge/pmd/lang/xml/XmlLanguageModule.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.xml;
import static net.sourceforge.pmd.util.CollectionUtil.listOf;
import java.util.List;
import net.sourceforge.pmd.annotation.InternalApi;
import net.sourceforge.pmd.lang.impl.SimpleLanguageModuleBase;
/**
* Created by christoferdutz on 20.09.14.
*/
public class XmlLanguageModule extends SimpleLanguageModuleBase {
public static final String NAME = "XML";
public static final String TERSE_NAME = "xml";
@InternalApi
public static final List<String> EXTENSIONS = listOf("xml");
public XmlLanguageModule() {
super(LanguageMetadata.withId(TERSE_NAME).name(NAME)
.extensions(EXTENSIONS)
.addVersion("1.0")
.addDefaultVersion("1.1"),
new XmlHandler());
}
}
| 923 | 27.875 | 79 | java |
pmd | pmd-master/pmd-xml/src/main/java/net/sourceforge/pmd/lang/xml/ast/XmlNode.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.xml.ast;
import net.sourceforge.pmd.lang.ast.impl.GenericNode;
/**
* This interface represents all XML AST nodes. They are essentially thin
* wrappers around the underlying DOM nodes.
*/
public interface XmlNode extends GenericNode<XmlNode> {
/**
* Provide access to the underlying DOM node.
*
* @return The DOM node.
*/
org.w3c.dom.Node getNode();
}
| 507 | 22.090909 | 79 | java |
pmd | pmd-master/pmd-xml/src/main/java/net/sourceforge/pmd/lang/xml/ast/internal/XmlParserImpl.java | /*
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.xml.ast.internal;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.StringReader;
import java.util.HashMap;
import java.util.Map;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.xml.sax.EntityResolver;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import net.sourceforge.pmd.lang.ast.AstInfo;
import net.sourceforge.pmd.lang.ast.ParseException;
import net.sourceforge.pmd.lang.ast.Parser.ParserTask;
import net.sourceforge.pmd.lang.ast.RootNode;
import net.sourceforge.pmd.lang.xml.ast.XmlNode;
public final class XmlParserImpl {
// never throws on unresolved resource
private static final EntityResolver SILENT_ENTITY_RESOLVER = (publicId, systemId) -> new InputSource(new ByteArrayInputStream("".getBytes()));
private final Map<org.w3c.dom.Node, XmlNode> nodeCache = new HashMap<>();
private Document parseDocument(String xmlData) throws ParseException {
nodeCache.clear();
try {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
dbf.setNamespaceAware(true);
dbf.setValidating(false);
dbf.setIgnoringComments(false);
dbf.setIgnoringElementContentWhitespace(false);
dbf.setExpandEntityReferences(true);
dbf.setCoalescing(false);
dbf.setXIncludeAware(false);
dbf.setFeature("http://xml.org/sax/features/external-general-entities", false);
dbf.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
DocumentBuilder documentBuilder = dbf.newDocumentBuilder();
documentBuilder.setEntityResolver(SILENT_ENTITY_RESOLVER);
return documentBuilder.parse(new InputSource(new StringReader(xmlData)));
} catch (ParserConfigurationException | SAXException | IOException e) {
throw new ParseException(e);
}
}
public RootXmlNode parse(ParserTask task) {
String xmlData = task.getSourceText();
Document document = parseDocument(xmlData);
RootXmlNode root = new RootXmlNode(this, document, task);
DOMLineNumbers lineNumbers = new DOMLineNumbers(root, task.getTextDocument());
lineNumbers.determine();
nodeCache.put(document, root);
return root;
}
/**
* Gets the wrapper for a DOM node, implementing PMD interfaces.
*
* @param domNode The node to wrap
*
* @return The wrapper
*/
XmlNode wrapDomNode(Node domNode) {
XmlNode wrapper = nodeCache.get(domNode);
if (wrapper == null) {
wrapper = new XmlNodeWrapper(this, domNode);
nodeCache.put(domNode, wrapper);
}
return wrapper;
}
/**
* The root should implement {@link RootNode}.
*/
public static class RootXmlNode extends XmlNodeWrapper implements RootNode {
private final AstInfo<RootXmlNode> astInfo;
RootXmlNode(XmlParserImpl parser, Document domNode, ParserTask task) {
super(parser, domNode);
this.astInfo = new AstInfo<>(task, this);
}
@Override
public AstInfo<RootXmlNode> getAstInfo() {
return astInfo;
}
@Override
public XmlNode wrap(Node domNode) {
return super.wrap(domNode);
}
@Override
public Document getNode() {
return (Document) super.getNode();
}
}
}
| 3,752 | 31.921053 | 146 | java |
pmd | pmd-master/pmd-xml/src/main/java/net/sourceforge/pmd/lang/xml/ast/internal/XmlNodeWrapper.java | /*
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.xml.ast.internal;
import static java.util.Collections.emptyIterator;
import java.util.AbstractList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Text;
import net.sourceforge.pmd.lang.document.TextDocument;
import net.sourceforge.pmd.lang.document.TextRegion;
import net.sourceforge.pmd.lang.rule.xpath.Attribute;
import net.sourceforge.pmd.lang.rule.xpath.internal.CoordinateXPathFunction;
import net.sourceforge.pmd.lang.xml.ast.XmlNode;
import net.sourceforge.pmd.util.DataMap;
import net.sourceforge.pmd.util.DataMap.DataKey;
import net.sourceforge.pmd.util.IteratorUtil;
/**
* Proxy wrapping an XML DOM node ({@link org.w3c.dom.Node}) to implement PMD interfaces.
*
* @author Clément Fournier
* @since 6.1.0
*/
class XmlNodeWrapper implements XmlNode {
private DataMap<DataKey<?, ?>> dataMap;
private final XmlParserImpl parser;
private final org.w3c.dom.Node node;
int startOffset;
int endOffset;
TextDocument textDoc;
XmlNodeWrapper(XmlParserImpl parser, org.w3c.dom.Node domNode) {
super();
this.node = domNode;
this.parser = parser;
domNode.setUserData(CoordinateXPathFunction.PMD_NODE_USER_DATA, this, null);
}
protected XmlNode wrap(org.w3c.dom.Node domNode) {
return parser.wrapDomNode(domNode);
}
@Override
public TextRegion getTextRegion() {
return TextRegion.fromBothOffsets(startOffset, endOffset);
}
@Override
public XmlNode getParent() {
org.w3c.dom.Node parent = node.getParentNode();
return parent != null ? parser.wrapDomNode(parent) : null;
}
@Override
public int getIndexInParent() {
org.w3c.dom.Node parent = node.getParentNode();
if (parent == null) {
return -1;
}
NodeList childNodes = parent.getChildNodes();
for (int i = 0; i < childNodes.getLength(); i++) {
if (node == childNodes.item(i)) { // NOPMD CompareObjectsWithEquals
return i;
}
}
throw new IllegalStateException("This node is not a child of its parent: " + node);
}
@Override
public XmlNode getChild(int index) {
return parser.wrapDomNode(node.getChildNodes().item(index));
}
@Override
public int getNumChildren() {
return node.hasChildNodes() ? node.getChildNodes().getLength() : 0;
}
@Override
public String getImage() {
return node instanceof Text ? ((Text) node).getData() : null;
}
@Override
public boolean hasImageEqualTo(String image) {
return Objects.equals(image, getImage());
}
@Override
public boolean isFindBoundary() {
return false;
}
@Override
public DataMap<DataKey<?, ?>> getUserMap() {
if (dataMap == null) {
dataMap = DataMap.newDataMap();
}
return dataMap;
}
@Override
public String getXPathNodeName() {
return node.getNodeName().replace("#", "");
}
@Override
public String toString() {
return node.getNodeName().replace("#", "");
}
@Override
public Iterator<Attribute> getXPathAttributesIterator() {
// Expose Text/CDATA nodes to have an 'Image' attribute like AST Nodes
if (node instanceof Text) {
return Collections.singletonList(new Attribute(this, "Image", ((Text) node).getData())).iterator();
}
// Expose DOM Attributes
if (node.getAttributes() == null) {
return emptyIterator();
} else {
return IteratorUtil.map(
asList(node.getAttributes()).iterator(),
n -> new Attribute(this, n.getNodeName(), n.getNodeValue())
);
}
}
private static List<Node> asList(NamedNodeMap nodeList) {
return new AbstractList<Node>() {
@Override
public Node get(int index) {
return nodeList.item(index);
}
@Override
public int size() {
return nodeList.getLength();
}
};
}
@Override
public org.w3c.dom.Node getNode() {
return node;
}
}
| 4,490 | 24.662857 | 111 | java |
pmd | pmd-master/pmd-xml/src/main/java/net/sourceforge/pmd/lang/xml/ast/internal/DOMLineNumbers.java | /*
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.xml.ast.internal;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.w3c.dom.DocumentType;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.ProcessingInstruction;
import net.sourceforge.pmd.lang.document.Chars;
import net.sourceforge.pmd.lang.document.TextDocument;
import net.sourceforge.pmd.lang.xml.ast.internal.XmlParserImpl.RootXmlNode;
/**
*
*/
class DOMLineNumbers {
private final RootXmlNode document;
private final TextDocument textDocument;
private Chars xmlString;
DOMLineNumbers(RootXmlNode root, TextDocument textDocument) {
this.document = root;
this.xmlString = textDocument.getText();
this.textDocument = textDocument;
}
void determine() {
determineLocation(document, 0);
}
private int determineLocation(XmlNodeWrapper wrapper, int index) {
int nextIndex = index;
int nodeLength = 0;
int textLength = 0;
org.w3c.dom.Node n = wrapper.getNode();
if (n.getNodeType() == Node.DOCUMENT_TYPE_NODE) {
nextIndex = xmlString.indexOf("<!DOCTYPE", nextIndex);
} else if (n.getNodeType() == Node.COMMENT_NODE) {
nextIndex = xmlString.indexOf("<!--", nextIndex);
} else if (n.getNodeType() == Node.ELEMENT_NODE) {
nextIndex = xmlString.indexOf("<" + n.getNodeName(), nextIndex);
nodeLength = xmlString.indexOf(">", nextIndex) - nextIndex + 1;
} else if (n.getNodeType() == Node.CDATA_SECTION_NODE) {
nextIndex = xmlString.indexOf("<![CDATA[", nextIndex);
} else if (n.getNodeType() == Node.PROCESSING_INSTRUCTION_NODE) {
ProcessingInstruction pi = (ProcessingInstruction) n;
nextIndex = xmlString.indexOf("<?" + pi.getTarget(), nextIndex);
} else if (n.getNodeType() == Node.TEXT_NODE) {
String te = unexpandEntities(n, n.getNodeValue(), true);
int newIndex = xmlString.indexOf(te, nextIndex);
if (newIndex == -1) {
// try again without escaping the quotes
te = unexpandEntities(n, n.getNodeValue(), false);
newIndex = xmlString.indexOf(te, nextIndex);
}
if (newIndex > 0) {
textLength = te.length();
nextIndex = newIndex;
}
} else if (n.getNodeType() == Node.ENTITY_REFERENCE_NODE) {
nextIndex = xmlString.indexOf("&" + n.getNodeName() + ";", nextIndex);
}
setBeginLocation(wrapper, nextIndex);
nextIndex += nodeLength;
if (n.hasChildNodes()) {
int numChildren = wrapper.getNumChildren();
for (int i = 0; i < numChildren; i++) {
nextIndex = determineLocation((XmlNodeWrapper) wrapper.getChild(i), nextIndex);
}
}
// autoclosing element, eg <a />
boolean isAutoClose = !n.hasChildNodes()
&& n.getNodeType() == Node.ELEMENT_NODE
// nextIndex is up to the closing > at this point
&& xmlString.startsWith("/>", nextIndex - 2);
if (n.getNodeType() == Node.ELEMENT_NODE && !isAutoClose) {
nextIndex += 2 + n.getNodeName().length() + 1; // </nodename>
} else if (n.getNodeType() == Node.DOCUMENT_TYPE_NODE) {
Node nextSibling = n.getNextSibling();
if (nextSibling.getNodeType() == Node.ELEMENT_NODE) {
nextIndex = xmlString.indexOf("<" + nextSibling.getNodeName(), nextIndex) - 1;
} else if (nextSibling.getNodeType() == Node.COMMENT_NODE) {
nextIndex = xmlString.indexOf("<!--", nextIndex);
} else {
nextIndex = xmlString.indexOf(">", nextIndex);
}
} else if (n.getNodeType() == Node.COMMENT_NODE) {
nextIndex += 4 + 3; // <!-- and -->
nextIndex += n.getNodeValue().length();
} else if (n.getNodeType() == Node.TEXT_NODE) {
nextIndex += textLength;
} else if (n.getNodeType() == Node.CDATA_SECTION_NODE) {
nextIndex += "<![CDATA[".length() + n.getNodeValue().length() + "]]>".length();
} else if (n.getNodeType() == Node.PROCESSING_INSTRUCTION_NODE) {
ProcessingInstruction pi = (ProcessingInstruction) n;
nextIndex += "<?".length() + pi.getTarget().length() + "?>".length() + pi.getData().length();
}
setEndLocation(wrapper, nextIndex - 1);
return nextIndex;
}
private String unexpandEntities(Node n, String te, boolean withQuotes) {
String result = te;
DocumentType doctype = n.getOwnerDocument().getDoctype();
// implicit entities
result = result.replaceAll(Matcher.quoteReplacement("&"), "&");
result = result.replaceAll(Matcher.quoteReplacement("<"), "<");
result = result.replaceAll(Matcher.quoteReplacement(">"), ">");
if (withQuotes) {
result = result.replaceAll(Matcher.quoteReplacement("\""), """);
result = result.replaceAll(Matcher.quoteReplacement("'"), "'");
}
if (doctype != null) {
NamedNodeMap entities = doctype.getEntities();
String internalSubset = doctype.getInternalSubset();
if (internalSubset == null) {
internalSubset = "";
}
for (int i = 0; i < entities.getLength(); i++) {
Node item = entities.item(i);
String entityName = item.getNodeName();
Node firstChild = item.getFirstChild();
if (firstChild != null) {
result = result.replaceAll(Matcher.quoteReplacement(firstChild.getNodeValue()),
"&" + entityName + ";");
} else {
Matcher m = Pattern
.compile(Matcher.quoteReplacement("<!ENTITY " + entityName + " ") + "[']([^']*)[']>")
.matcher(internalSubset);
if (m.find()) {
result = result.replaceAll(Matcher.quoteReplacement(m.group(1)), "&" + entityName + ";");
}
}
}
}
return result;
}
private void setBeginLocation(XmlNodeWrapper n, int index) {
if (n != null) {
n.startOffset = index;
n.textDoc = textDocument;
}
}
private void setEndLocation(XmlNodeWrapper n, int index) {
if (n != null) {
n.endOffset = index;
}
}
}
| 6,755 | 40.447853 | 113 | java |
pmd | pmd-master/pmd-xml/src/main/java/net/sourceforge/pmd/lang/xml/rule/SaxonDomXPathQuery.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.xml.rule;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
import org.apache.commons.lang3.exception.ContextedRuntimeException;
import org.w3c.dom.Document;
import net.sourceforge.pmd.lang.ast.Node;
import net.sourceforge.pmd.lang.rule.xpath.impl.XPathHandler;
import net.sourceforge.pmd.lang.rule.xpath.internal.DomainConversion;
import net.sourceforge.pmd.lang.xml.ast.XmlNode;
import net.sourceforge.pmd.lang.xml.ast.internal.XmlParserImpl.RootXmlNode;
import net.sourceforge.pmd.properties.PropertyDescriptor;
import net.sourceforge.pmd.properties.PropertySource;
import net.sourceforge.pmd.util.DataMap;
import net.sourceforge.pmd.util.DataMap.DataKey;
import net.sourceforge.pmd.util.DataMap.SimpleDataKey;
import net.sf.saxon.Configuration;
import net.sf.saxon.dom.DocumentWrapper;
import net.sf.saxon.lib.ExtensionFunctionDefinition;
import net.sf.saxon.lib.NamespaceConstant;
import net.sf.saxon.om.AtomicSequence;
import net.sf.saxon.om.Item;
import net.sf.saxon.om.NamePool;
import net.sf.saxon.om.StructuredQName;
import net.sf.saxon.sxpath.IndependentContext;
import net.sf.saxon.sxpath.XPathDynamicContext;
import net.sf.saxon.sxpath.XPathEvaluator;
import net.sf.saxon.sxpath.XPathExpression;
import net.sf.saxon.sxpath.XPathStaticContext;
import net.sf.saxon.sxpath.XPathVariable;
import net.sf.saxon.trans.XPathException;
import net.sf.saxon.tree.wrapper.AbstractNodeWrapper;
final class SaxonDomXPathQuery {
private static final NamePool NAME_POOL = new NamePool();
private static final SimpleDataKey<DocumentWrapper> SAXON_DOM_WRAPPER
= DataMap.simpleDataKey("pmd.saxon.dom.wrapper");
/** The XPath expression as a string. */
private final String xpath;
private final XPathHandler xpathHandler;
/** The executable XPath expression. */
private final XPathExpressionWithProperties xpathExpression;
private final Configuration configuration;
SaxonDomXPathQuery(String xpath,
String defaultNsUri,
List<PropertyDescriptor<?>> properties,
XPathHandler xpathHandler) {
this.xpath = xpath;
this.xpathHandler = xpathHandler;
configuration = new Configuration();
configuration.setNamePool(NAME_POOL);
xpathExpression = makeXPathExpression(this.xpath, defaultNsUri, properties);
}
private XPathExpressionWithProperties makeXPathExpression(String xpath, String defaultUri, List<PropertyDescriptor<?>> properties) {
final IndependentContext xpathStaticContext = new IndependentContext(configuration);
xpathStaticContext.declareNamespace("fn", NamespaceConstant.FN);
xpathStaticContext.setDefaultElementNamespace(defaultUri);
for (ExtensionFunctionDefinition fun : xpathHandler.getRegisteredExtensionFunctions()) {
StructuredQName qname = fun.getFunctionQName();
xpathStaticContext.declareNamespace(qname.getPrefix(), qname.getURI());
this.configuration.registerExtensionFunction(fun);
}
Map<PropertyDescriptor<?>, XPathVariable> xpathVariables = declareXPathVariables(properties, xpathStaticContext);
try {
final XPathEvaluator xpathEvaluator = new XPathEvaluator(configuration);
xpathEvaluator.setStaticContext(xpathStaticContext);
XPathExpression expression = xpathEvaluator.createExpression(xpath);
return new XPathExpressionWithProperties(
expression,
xpathVariables
);
} catch (final XPathException e) {
throw new ContextedRuntimeException(e)
.addContextValue("XPath", xpath);
}
}
private Map<PropertyDescriptor<?>, XPathVariable> declareXPathVariables(List<PropertyDescriptor<?>> accessibleProperties, XPathStaticContext xpathStaticContext) {
Map<PropertyDescriptor<?>, XPathVariable> xpathVariables = new HashMap<>();
for (final PropertyDescriptor<?> propertyDescriptor : accessibleProperties) {
final String name = propertyDescriptor.name();
if (!isExcludedProperty(name)) {
final XPathVariable xpathVariable = xpathStaticContext.declareVariable(null, name);
xpathVariables.put(propertyDescriptor, xpathVariable);
}
}
return Collections.unmodifiableMap(xpathVariables);
}
private boolean isExcludedProperty(String name) {
return "xpath".equals(name)
|| "defaultNsUri".equals(name)
|| "violationSuppressRegex".equals(name)
|| "violationSuppressXPath".equals(name);
}
@Override
public String toString() {
return xpath;
}
public List<Node> evaluate(RootXmlNode root, PropertySource propertyValues) {
DocumentWrapper wrapper = getSaxonDomWrapper(root);
try {
List<Node> result = new ArrayList<>();
for (Item item : this.xpathExpression.evaluate(wrapper, propertyValues)) {
if (item instanceof AbstractNodeWrapper) {
AbstractNodeWrapper nodeInfo = (AbstractNodeWrapper) item;
Object domNode = nodeInfo.getUnderlyingNode();
if (domNode instanceof org.w3c.dom.Node) {
XmlNode wrapped = root.wrap((org.w3c.dom.Node) domNode);
result.add(wrapped);
}
}
}
return result;
} catch (XPathException e) {
throw new ContextedRuntimeException(e)
.addContextValue("XPath", xpath);
}
}
private DocumentWrapper getSaxonDomWrapper(RootXmlNode node) {
DataMap<DataKey<?, ?>> userMap = node.getUserMap();
if (userMap.isSet(SAXON_DOM_WRAPPER)) {
return userMap.get(SAXON_DOM_WRAPPER);
}
Document domRoot = node.getNode();
DocumentWrapper wrapper = new DocumentWrapper(
domRoot, domRoot.getBaseURI(), configuration
);
userMap.set(SAXON_DOM_WRAPPER, wrapper);
return wrapper;
}
static final class XPathExpressionWithProperties {
final XPathExpression expr;
final Map<PropertyDescriptor<?>, XPathVariable> xpathVariables;
XPathExpressionWithProperties(XPathExpression expr, Map<PropertyDescriptor<?>, XPathVariable> xpathVariables) {
this.expr = expr;
this.xpathVariables = xpathVariables;
}
private List<Item> evaluate(final DocumentWrapper elementNode, PropertySource properties) throws XPathException {
XPathDynamicContext dynamicContext = createDynamicContext(elementNode, properties);
return expr.evaluate(dynamicContext);
}
private XPathDynamicContext createDynamicContext(final DocumentWrapper elementNode, PropertySource properties) throws XPathException {
final XPathDynamicContext dynamicContext = expr.createDynamicContext(elementNode.getRootNode());
// Set variable values on the dynamic context
for (final Entry<PropertyDescriptor<?>, XPathVariable> entry : xpathVariables.entrySet()) {
AtomicSequence saxonValue = getSaxonValue(properties, entry);
XPathVariable variable = entry.getValue();
try {
dynamicContext.setVariable(variable, saxonValue);
} catch (XPathException e) {
throw new ContextedRuntimeException(e)
.addContextValue("Variable", variable);
}
}
return dynamicContext;
}
private static AtomicSequence getSaxonValue(PropertySource properties, Entry<PropertyDescriptor<?>, XPathVariable> entry) {
Object value = properties.getProperty(entry.getKey());
Objects.requireNonNull(value, "null property value for " + entry.getKey());
return DomainConversion.convert(value);
}
}
}
| 8,304 | 39.91133 | 166 | java |
pmd | pmd-master/pmd-xml/src/main/java/net/sourceforge/pmd/lang/xml/rule/AbstractXmlRule.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.xml.rule;
import net.sourceforge.pmd.lang.rule.AbstractRule;
/**
* This is a base class for XML Java bases rules.
*/
public abstract class AbstractXmlRule extends AbstractRule {
}
| 308 | 18.3125 | 79 | java |
pmd | pmd-master/pmd-xml/src/main/java/net/sourceforge/pmd/lang/xml/rule/DomXPathRule.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.xml.rule;
import java.util.Objects;
import net.sourceforge.pmd.RuleContext;
import net.sourceforge.pmd.lang.LanguageProcessor;
import net.sourceforge.pmd.lang.ast.Node;
import net.sourceforge.pmd.lang.rule.AbstractRule;
import net.sourceforge.pmd.lang.rule.XPathRule;
import net.sourceforge.pmd.lang.xml.ast.internal.XmlParserImpl.RootXmlNode;
import net.sourceforge.pmd.properties.PropertyDescriptor;
import net.sourceforge.pmd.properties.PropertyFactory;
/**
* XPath rule that executes an expression on the DOM directly, and not
* on the PMD AST wrapper. The XPath expressions adheres to the XPath
* (2.0) spec, so they can be tested in any existing XPath testing tools
* instead of just the PMD designer (google "xpath test"). Usage of this
* class is strongly recommended over the standard {@link XPathRule}, which
* is mostly useful in other PMD languages.
*
* <h3>Differences with {@link XPathRule}</h3>
*
* This rule and {@link XPathRule} do not accept exactly the same queries,
* because {@link XPathRule} implements the XPath spec in an ad-hoc way.
* The main differences are:
* <ul>
* <li>{@link XPathRule} uses <i>elements</i> to represent text nodes.
* This is contrary to the XPath spec, in which element and text nodes
* are different kinds of nodes. To replace the query {@code //elt/text[@Image="abc"]},
* use the XPath function {@code text()}, eg {@code //elt[text()="abc"]}.
* <li>{@link XPathRule} adds additional attributes to each element
* (eg {@code @BeginLine} and {@code @Image}). These attributes are not
* XML attributes, so they are not accessible using DomXPathRule rule.
* Instead, use the XPath functions {@code pmd:startLine(node)}, {@code pmd:endLine(node)} and related.
* For instance, replace {@code //elt[@EndLine - @BeginLine > 10]} with
* {@code elt[pmd:endLine(.) - pmd:startLine(.) > 10]}.
* <li>{@link XPathRule} uses an element called {@code "document"} as the
* root node of every XML AST. This node does not have the correct node kind,
* as it's an element, not a document. To replace {@code /document/RootNode},
* use just {@code /RootNode}.
* <li>{@link XPathRule} ignores comments and processing instructions
* (eg FXML's {@code <?import javafx.Node ?>}).
* This rule makes them accessible with the regular XPath syntax.
* The following finds all comments in the file:
* <pre>{@code
* //comment()
* }</pre>
* The following finds only top-level comments starting with "prefix":
* <pre>{@code
* /comment()[fn:starts-with(fn:string(.), "prefix")]
* }</pre>
* Note the use of {@code fn:string}.
*
* As an example of matching processing instructions, the following
* fetches all {@code <?import ... ?>} processing instructions.
* <pre>{@code
* /processing-instruction('import')
* }</pre>
* The string value of the instruction can be found with {@code fn:string}.
* </li>
* </ul>
*
* <p>Additionally, this rule only supports XPath 2.0, with no option
* for configuration. This will be bumped to XPath 3.1 in PMD 7.
*
* <h4>Namespace-sensitivity</h4>
*
* <p>Another important difference is that this rule is namespace-sensitive.
* If the tested XML documents use a schema ({@code xmlns} attribute on the root),
* you should set the property {@code defaultNsUri} on the rule with
* the value of the {@code xmlns} attribute. Otherwise node tests won't
* match unless you use a wildcard URI prefix ({@code *:nodeName}).
*
* <p>For instance for the document
* <pre>{@code
* <foo xmlns="http://company.com/aschema">
* </foo>
* }</pre>
* the XPath query {@code //foo} will not match anything, while {@code //*:foo}
* will. If you set the property {@code defaultNsUri} to {@code "http://company.com/aschema"},
* then {@code //foo} will be expanded to {@code //Q{http://company.com/aschema}foo},
* and match the {@code foo} node. The behaviour is equivalent in the following
* document:
* <pre>{@code
* <my:foo xmlns:my='http://company.com/aschema'>
* </my:foo>
* }</pre>
*
* <p>However, for the document
* <pre>{@code
* <foo>
* </foo>
* }</pre>
* the XPath queries {@code //foo} and {@code //*:foo} both match, because
* {@code //foo} is expanded to {@code //Q{}foo} (local name foo, empty URI),
* and the document has no default namespace (= the empty default namespace).
*
* <p>Note that explicitly specifying URIs with {@code Q{...}localName}
* as in this documentation is XPath 3.1 syntax and will only be available
* in PMD 7.
*
* @since PMD 6.44.0
* @author Clément Fournier
*/
public class DomXPathRule extends AbstractRule {
SaxonDomXPathQuery query;
private static final PropertyDescriptor<String> XPATH_EXPR
= PropertyFactory.stringProperty("xpath")
.desc("An XPath 2.0 expression that will be evaluated against the root DOM")
.defaultValue("") // no default value
.build();
private static final PropertyDescriptor<String> DEFAULT_NS_URI
= PropertyFactory.stringProperty("defaultNsUri")
.desc("A URI for the default namespace of node tests in the XPath expression."
+ "This is provided to match documents based on their declared schema.")
.defaultValue("")
.build();
public DomXPathRule() {
definePropertyDescriptor(XPATH_EXPR);
definePropertyDescriptor(DEFAULT_NS_URI);
// for compatibility, but is ignored.
definePropertyDescriptor(XPathRule.VERSION_DESCRIPTOR);
}
public DomXPathRule(String xpath) {
this(xpath, "");
}
public DomXPathRule(String xpath, String defaultNsUri) {
this();
setProperty(XPATH_EXPR, xpath);
setProperty(DEFAULT_NS_URI, defaultNsUri);
}
@Override
public void apply(Node node, RuleContext ctx) {
RootXmlNode root = (RootXmlNode) node;
SaxonDomXPathQuery query = getXPathQuery();
for (Node foundNode : query.evaluate(root, this)) {
ctx.addViolation(foundNode);
}
}
@Override
public void initialize(LanguageProcessor languageProcessor) {
query = new SaxonDomXPathQuery(getProperty(XPATH_EXPR),
getProperty(DEFAULT_NS_URI),
getPropertyDescriptors(),
languageProcessor.services().getXPathHandler());
}
private SaxonDomXPathQuery getXPathQuery() {
return Objects.requireNonNull(query, "rule not initialized");
}
}
| 6,716 | 38.745562 | 103 | java |
pmd | pmd-master/pmd-xml/src/main/java/net/sourceforge/pmd/lang/pom/PomLanguageModule.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.pom;
import net.sourceforge.pmd.lang.impl.SimpleLanguageModuleBase;
import net.sourceforge.pmd.lang.xml.XmlHandler;
public class PomLanguageModule extends SimpleLanguageModuleBase {
public static final String NAME = "Maven POM";
public static final String TERSE_NAME = "pom";
public PomLanguageModule() {
super(LanguageMetadata.withId(TERSE_NAME).name(NAME)
.extensions("pom")
.addDefaultVersion("4.0.0"),
new XmlHandler());
}
}
| 655 | 28.818182 | 79 | java |
pmd | pmd-master/pmd-xml/src/main/java/net/sourceforge/pmd/xml/cpd/XmlTokenizer.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.xml.cpd;
import org.antlr.v4.runtime.CharStream;
import org.antlr.v4.runtime.Lexer;
import net.sourceforge.pmd.cpd.impl.AntlrTokenizer;
import net.sourceforge.pmd.lang.xml.antlr4.XMLLexer;
public class XmlTokenizer extends AntlrTokenizer {
@Override
protected Lexer getLexerForSource(CharStream charStream) {
return new XMLLexer(charStream);
}
}
| 487 | 23.4 | 79 | java |
pmd | pmd-master/pmd-xml/src/main/java/net/sourceforge/pmd/xml/cpd/XmlLanguage.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.xml.cpd;
import net.sourceforge.pmd.cpd.AbstractLanguage;
import net.sourceforge.pmd.lang.xml.XmlLanguageModule;
public class XmlLanguage extends AbstractLanguage {
public XmlLanguage() {
super(XmlLanguageModule.NAME, XmlLanguageModule.TERSE_NAME, new XmlTokenizer(), XmlLanguageModule.EXTENSIONS);
}
}
| 439 | 26.5 | 118 | java |
pmd | pmd-master/pmd-gherkin/src/test/java/net/sourceforge/pmd/cpd/GherkinTokenizerTest.java | /*
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.cpd;
import java.util.Properties;
import org.junit.jupiter.api.Test;
import net.sourceforge.pmd.cpd.test.CpdTextComparisonTest;
import net.sourceforge.pmd.lang.gherkin.cpd.GherkinTokenizer;
class GherkinTokenizerTest extends CpdTextComparisonTest {
GherkinTokenizerTest() {
super(".feature");
}
@Override
protected String getResourcePrefix() {
return "../lang/gherkin/cpd/testdata";
}
@Override
public Tokenizer newTokenizer(Properties properties) {
GherkinTokenizer tok = new GherkinTokenizer();
return tok;
}
@Test
void testAnnotatedSource() {
doTest("annotatedSource");
}
@Test
void testDocstring() {
doTest("docstring");
}
}
| 857 | 20.45 | 79 | java |
pmd | pmd-master/pmd-gherkin/src/main/java/net/sourceforge/pmd/lang/gherkin/ast/package-info.java | /*
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
/**
* Contains the Antlr grammar for Gherkin.
*/
package net.sourceforge.pmd.lang.gherkin.ast;
| 186 | 19.777778 | 79 | java |
pmd | pmd-master/pmd-gherkin/src/main/java/net/sourceforge/pmd/lang/gherkin/cpd/package-info.java | /*
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
/**
* Contains Gherkin tokenizer and language classes.
*/
package net.sourceforge.pmd.lang.gherkin.cpd;
| 195 | 20.777778 | 79 | java |
pmd | pmd-master/pmd-gherkin/src/main/java/net/sourceforge/pmd/lang/gherkin/cpd/GherkinTokenizer.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.gherkin.cpd;
import org.antlr.v4.runtime.CharStream;
import org.antlr.v4.runtime.Lexer;
import net.sourceforge.pmd.cpd.impl.AntlrTokenizer;
import net.sourceforge.pmd.lang.gherkin.ast.GherkinLexer;
/**
* The Gherkin Tokenizer.
*/
public class GherkinTokenizer extends AntlrTokenizer {
@Override
protected Lexer getLexerForSource(CharStream charStream) {
return new GherkinLexer(charStream);
}
}
| 543 | 22.652174 | 79 | java |
pmd | pmd-master/pmd-gherkin/src/main/java/net/sourceforge/pmd/lang/gherkin/cpd/GherkinLanguage.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.gherkin.cpd;
import net.sourceforge.pmd.cpd.AbstractLanguage;
/**
* Language implementation for Gherkin.
*/
public class GherkinLanguage extends AbstractLanguage {
/**
* Creates a new Gherkin Language instance.
*/
public GherkinLanguage() {
super("Gherkin", "gherkin", new GherkinTokenizer(), ".feature");
}
}
| 467 | 21.285714 | 79 | java |
pmd | pmd-master/pmd-modelica/src/test/java/net/sourceforge/pmd/lang/modelica/RuleSetFactoryTest.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica;
import net.sourceforge.pmd.AbstractRuleSetFactoryTest;
class RuleSetFactoryTest extends AbstractRuleSetFactoryTest {
// no additional tests yet
}
| 284 | 22.75 | 79 | java |
pmd | pmd-master/pmd-modelica/src/test/java/net/sourceforge/pmd/lang/modelica/LanguageVersionTest.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica;
import java.util.Arrays;
import java.util.Collection;
import net.sourceforge.pmd.AbstractLanguageVersionTest;
class LanguageVersionTest extends AbstractLanguageVersionTest {
static Collection<TestDescriptor> data() {
return Arrays.asList(new TestDescriptor(ModelicaLanguageModule.NAME, ModelicaLanguageModule.TERSE_NAME, "3.5",
getLanguage(ModelicaLanguageModule.NAME).getDefaultVersion()));
}
}
| 564 | 28.736842 | 118 | java |
pmd | pmd-master/pmd-modelica/src/test/java/net/sourceforge/pmd/lang/modelica/ModelicaParsingHelper.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica;
import net.sourceforge.pmd.lang.ast.test.BaseParsingHelper;
import net.sourceforge.pmd.lang.modelica.ast.ASTStoredDefinition;
public class ModelicaParsingHelper extends BaseParsingHelper<ModelicaParsingHelper, ASTStoredDefinition> {
/** This runs all processing stages when parsing. */
public static final ModelicaParsingHelper DEFAULT = new ModelicaParsingHelper(Params.getDefault());
private ModelicaParsingHelper(Params params) {
super(ModelicaLanguageModule.NAME, ASTStoredDefinition.class, params);
}
@Override
protected ModelicaParsingHelper clone(Params params) {
return new ModelicaParsingHelper(params);
}
}
| 800 | 29.807692 | 106 | java |
pmd | pmd-master/pmd-modelica/src/test/java/net/sourceforge/pmd/lang/modelica/ModelicaParserTest.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica;
import org.junit.jupiter.api.Test;
class ModelicaParserTest {
@Test
void testParsingGrapgical() {
ModelicaParsingHelper.DEFAULT.parseResource("ParserTestGraphical.mo");
}
@Test
void testParsingTextual() {
ModelicaParsingHelper.DEFAULT.parseResource("ParserTestTextual.mo");
}
}
| 453 | 21.7 | 79 | java |
pmd | pmd-master/pmd-modelica/src/test/java/net/sourceforge/pmd/lang/modelica/rule/bestpractices/AmbiguousResolutionTest.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.rule.bestpractices;
import net.sourceforge.pmd.testframework.PmdRuleTst;
class AmbiguousResolutionTest extends PmdRuleTst {
// no additional unit tests
}
| 291 | 23.333333 | 79 | java |
pmd | pmd-master/pmd-modelica/src/test/java/net/sourceforge/pmd/lang/modelica/rule/bestpractices/ConnectUsingNonConnectorTest.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.rule.bestpractices;
import net.sourceforge.pmd.testframework.PmdRuleTst;
class ConnectUsingNonConnectorTest extends PmdRuleTst {
// no additional unit tests
}
| 296 | 23.75 | 79 | java |
pmd | pmd-master/pmd-modelica/src/test/java/net/sourceforge/pmd/lang/modelica/rule/bestpractices/ClassStartNameEqualsEndNameTest.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.rule.bestpractices;
import net.sourceforge.pmd.testframework.PmdRuleTst;
class ClassStartNameEqualsEndNameTest extends PmdRuleTst {
// no additional unit tests
}
| 299 | 24 | 79 | java |
pmd | pmd-master/pmd-modelica/src/test/java/net/sourceforge/pmd/lang/modelica/resolver/ModelicaResolverTest.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.resolver;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.List;
import org.junit.jupiter.api.Test;
import net.sourceforge.pmd.lang.modelica.ModelicaParsingHelper;
import net.sourceforge.pmd.lang.modelica.ast.ASTExtendsClause;
import net.sourceforge.pmd.lang.modelica.ast.ASTStoredDefinition;
import net.sourceforge.pmd.lang.modelica.ast.ModelicaClassSpecifierNode;
import net.sourceforge.pmd.lang.modelica.ast.ModelicaNode;
import net.sourceforge.pmd.lang.modelica.ast.ModelicaParserVisitorAdapter;
class ModelicaResolverTest {
private final ModelicaParsingHelper modelica = ModelicaParsingHelper.DEFAULT;
private static class NodeFinder extends ModelicaParserVisitorAdapter {
private ModelicaNode result;
private Class<?> nodeClass;
private String nodeName;
NodeFinder(Class<?> nodeClass, String nodeName) {
this.nodeClass = nodeClass;
this.nodeName = nodeName;
}
@Override
public Object visitModelicaNode(ModelicaNode node, Object data) {
if (nodeClass.isInstance(node) && node.getImage().equals(nodeName)) {
assertNull(result);
result = node;
}
return super.visitModelicaNode(node, data);
}
ModelicaNode getResult() {
return result;
}
}
private ModelicaNode findNodeByClassAndImage(ASTStoredDefinition ast, Class<?> clazz, String image) {
NodeFinder vis = new NodeFinder(clazz, image);
ast.acceptVisitor(vis, null);
return vis.getResult();
}
private void ensureCounts(ResolutionResult result, int best, int hidden) {
assertFalse(result.wasTimedOut());
assertEquals(best, result.getBestCandidates().size());
assertEquals(hidden, result.getHiddenCandidates().size());
}
private ResolutionResult<ResolvableEntity> resolveIn(int best, int hidden, ResolutionState state, SubcomponentResolver resolver, boolean absolute, String[] names) {
ResolutionResult<ResolvableEntity> result = resolver.safeResolveComponent(ResolvableEntity.class, state, CompositeName.create(absolute, names));
ensureCounts(result, best, hidden);
return result;
}
private ResolutionResult<ResolvableEntity> resolveIn(int best, int hidden, ResolutionState state, ModelicaScope resolver, boolean absolute, String[] names) {
ResolutionResult<ResolvableEntity> result = resolver.safeResolveLexically(ResolvableEntity.class, state, CompositeName.create(absolute, names));
ensureCounts(result, best, hidden);
return result;
}
private ResolutionResult<ResolvableEntity> testResolvedTypeCount(int best, int hidden, SubcomponentResolver scope, boolean absolute, String... names) {
return resolveIn(best, hidden, ResolutionState.forType(), scope, absolute, names);
}
private ResolutionResult<ResolvableEntity> testResolvedTypeCount(int best, int hidden, ModelicaScope scope, boolean absolute, String... names) {
return resolveIn(best, hidden, ResolutionState.forType(), scope, absolute, names);
}
private ResolutionResult<ResolvableEntity> testResolvedComponentCount(int best, int hidden, ModelicaScope scope, boolean absolute, String... names) {
return resolveIn(best, hidden, ResolutionState.forComponentReference(), scope, absolute, names);
}
private ResolutionResult<ResolvableEntity> testLexicallyResolvedComponents(int best, int hidden, ModelicaClassScope scope, boolean absolute, String... names) {
ResolutionState state = ResolutionState.forComponentReference();
ResolutionResult<ResolvableEntity> result = scope.safeResolveLexically(ResolvableEntity.class, state, CompositeName.create(absolute, names));
ensureCounts(result, best, hidden);
return result;
}
@Test
void verySimpleScopeTest() {
String contents =
"model TestPackage"
+ " Real x;"
+ "end TestPackage;";
ASTStoredDefinition ast = modelica.parse(contents);
assertNotNull(ast);
assertTrue(ast.getMostSpecificScope() instanceof ModelicaSourceFileScope);
ModelicaSourceFileScope scope = (ModelicaSourceFileScope) ast.getMostSpecificScope();
assertTrue(scope.getParent() instanceof RootScope);
assertNull(scope.getParent().getParent());
}
@Test
void simpleScopeTest() {
String contents =
"package TestPackage"
+ " connector TestConnector"
+ " end TestConnector;"
+ " model TestModel"
+ " model TestSubmodel"
+ " end TestSubmodel;"
+ " end TestModel;"
+ " Real x;"
+ "end TestPackage;";
ASTStoredDefinition ast = modelica.parse(contents);
ModelicaSourceFileScope sourceFileScope = (ModelicaSourceFileScope) ast.getMostSpecificScope();
assertEquals(1, sourceFileScope.getContainedDeclarations().size());
ModelicaNode testSubmodel = findNodeByClassAndImage(ast, ModelicaClassSpecifierNode.class, "TestSubmodel");
assertNotNull(testSubmodel);
assertEquals(
"#ROOT#FILE#Class:TestPackage#Class:TestModel#Class:TestSubmodel",
((AbstractModelicaScope) testSubmodel.getMostSpecificScope()).getNestingRepresentation()
);
ModelicaScope testPackage = testSubmodel.getMostSpecificScope().getParent().getParent();
assertTrue(testPackage instanceof ModelicaClassScope);
assertEquals("TestPackage", ((ModelicaClassScope) testPackage).getClassDeclaration().getSimpleTypeName());
assertEquals(3, testPackage.getContainedDeclarations().size());
}
@Test
void extendsScopeTest() {
String contents =
"package Test"
+ " model A"
+ " extends B;"
+ " end A;"
+ " model B"
+ " end B;"
+ "end Test;";
ASTStoredDefinition ast = modelica.parse(contents);
List<ASTExtendsClause> extendsClauses = ast.findDescendantsOfType(ASTExtendsClause.class);
assertEquals(1, extendsClauses.size());
ASTExtendsClause extendsB = extendsClauses.get(0);
assertEquals("#ROOT#FILE#Class:Test#Class:A", ((AbstractModelicaScope) extendsB.getMostSpecificScope()).getNestingRepresentation());
}
@Test
void absoluteResolutionTest() {
String contents =
"package TestPackage"
+ " model TestModel"
+ " model TestSubmodel"
+ " end TestSubmodel;"
+ " end TestModel;"
+ "end TestPackage;";
ASTStoredDefinition ast = modelica.parse(contents);
testResolvedTypeCount(1, 0, ast.getMostSpecificScope(), true, "TestPackage", "TestModel", "TestSubmodel");
}
@Test
void nonAbsoluteResolutionTest() {
String contents =
"package TestPackage"
+ " model TestModel"
+ " model TestSubmodel"
+ " end TestSubmodel;"
+ " end TestModel;"
+ "end TestPackage;";
ASTStoredDefinition ast = modelica.parse(contents);
testResolvedTypeCount(1, 0, ast.getMostSpecificScope(), false, "TestPackage", "TestModel", "TestSubmodel");
}
@Test
void multipleResolutionTest() {
String contents =
"package TestPackage"
+ " model TestModel"
+ " model A"
+ " end A;"
+ " end TestModel;"
+ " model A"
+ " end A;"
+ " Real x;"
+ "end TestPackage;";
ASTStoredDefinition ast = modelica.parse(contents);
ResolutionResult<ResolvableEntity> testModelCandidates = testResolvedTypeCount(1, 0, ast.getMostSpecificScope(), true, "TestPackage", "TestModel");
ModelicaClassScope testModelScope = ((ModelicaClassType) testModelCandidates.getBestCandidates().get(0)).getClassScope();
assertEquals(
"#ROOT#FILE#Class:TestPackage#Class:TestModel",
testModelScope.getNestingRepresentation()
);
ResolutionResult<ResolvableEntity> aCandidates = testLexicallyResolvedComponents(1, 1, testModelScope, false, "A");
ModelicaClassType aBest = (ModelicaClassType) aCandidates.getBestCandidates().get(0);
ModelicaClassType aHidden = (ModelicaClassType) aCandidates.getHiddenCandidates().get(0);
assertEquals("#ROOT#FILE#Class:TestPackage#Class:TestModel#Class:A",
aBest.getClassScope().getNestingRepresentation());
assertEquals("#ROOT#FILE#Class:TestPackage#Class:A",
aHidden.getClassScope().getNestingRepresentation());
}
@Test
void constantComponentResolutionTest() {
String contents =
"model Test"
+ " model A"
+ " constant Real x = 1;"
+ " end A;"
+ "end Test;";
ASTStoredDefinition ast = modelica.parse(contents);
List<ResolvableEntity> xs = testResolvedTypeCount(1, 0, ast.getMostSpecificScope(), false, "Test", "A", "x").getBestCandidates();
assertEquals(
"#ROOT#FILE#Class:Test#Class:A",
((ModelicaComponentDeclaration) xs.get(0)).getContainingScope().getNestingRepresentation()
);
}
@Test
void nestedStoredDefinitionTest() {
String contents =
"within TestPackage.SubPackage;\n"
+ "model Test\n"
+ "end Test;\n";
ASTStoredDefinition ast = modelica.parse(contents);
RootScope rootScope = (RootScope) ast.getMostSpecificScope().getParent();
List<ResolvableEntity> nestedTest = testResolvedTypeCount(1, 0, rootScope, false, "TestPackage", "SubPackage", "Test").getBestCandidates();
assertEquals(
"#ROOT#FILE#Class:Test",
((ModelicaClassType) nestedTest.get(0)).getClassScope().getNestingRepresentation()
);
// Simple names are visible from within the same file
testResolvedTypeCount(1, 0, ast.getMostSpecificScope(), false, "Test");
// ... but from other files they should be resolved w.r.t. the within clause
testResolvedTypeCount(0, 0, rootScope, false, "Test");
}
@Test
void extendsTest() {
String contents =
"model A\n"
+ " model X\n"
+ " end X;\n"
+ "end A;\n"
+ "model B\n"
+ " extends A;"
+ "end B;";
ASTStoredDefinition ast = modelica.parse(contents);
testResolvedTypeCount(1, 0, ast.getMostSpecificScope(), false, "B", "X");
}
@Test
void importTest() {
String contents =
"model I\n"
+ " model Z\n"
+ " end Z;\n"
+ "end I;\n"
+ "model A\n"
+ " import I.Z;\n"
+ " model X\n"
+ " end X;\n"
+ "end A;\n"
+ "model B\n"
+ " extends A;"
+ "end B;";
ASTStoredDefinition ast = modelica.parse(contents);
testResolvedTypeCount(1, 0, ast.getMostSpecificScope(), false, "A", "Z");
testResolvedTypeCount(0, 0, ast.getMostSpecificScope(), false, "B", "Z");
}
@Test
void builtinTest() {
String contents =
"model A"
+ " encapsulated model B"
+ " Real x;"
+ " end B;"
+ "end A;";
ASTStoredDefinition ast = modelica.parse(contents);
List<ResolvableEntity> xs = testResolvedComponentCount(1, 0, ast.getMostSpecificScope(), true, "A", "B", "x").getBestCandidates();
ModelicaComponentDeclaration x = (ModelicaComponentDeclaration) xs.get(0);
ResolutionResult<ModelicaType> xTypes = x.getTypeCandidates();
ensureCounts(xTypes, 1, 0);
ResolvableEntity tpe = xTypes.getBestCandidates().get(0);
assertTrue(tpe instanceof ModelicaBuiltinType);
assertEquals(ModelicaBuiltinType.BaseType.REAL, ((ModelicaBuiltinType) tpe).getBaseType());
}
@Test
void testRepeatingNameResolution() {
String contents =
"package Test"
+ " model X"
+ " model X"
+ " end X;"
+ " Test.X.X mdl;"
+ " end X;"
+ "end Test;";
ASTStoredDefinition ast = modelica.parse(contents);
testResolvedTypeCount(1, 0, ast.getMostSpecificScope(), true, "Test", "X", "X");
testResolvedTypeCount(1, 0, ast.getMostSpecificScope(), false, "Test", "X", "X");
ResolutionResult<ResolvableEntity> result = testResolvedComponentCount(1, 0, ast.getMostSpecificScope(), false, "Test", "X", "mdl");
ModelicaComponentDeclaration mdl = (ModelicaComponentDeclaration) result.getBestCandidates().get(0);
ensureCounts(mdl.getTypeCandidates(), 1, 0);
}
}
| 13,501 | 38.479532 | 168 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/ModelicaLanguageModule.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica;
import static net.sourceforge.pmd.util.CollectionUtil.listOf;
import java.util.List;
import net.sourceforge.pmd.annotation.InternalApi;
import net.sourceforge.pmd.lang.impl.SimpleLanguageModuleBase;
public class ModelicaLanguageModule extends SimpleLanguageModuleBase {
public static final String NAME = "Modelica";
public static final String TERSE_NAME = "modelica";
@InternalApi
public static final List<String> EXTENSIONS = listOf("mo");
public ModelicaLanguageModule() {
super(LanguageMetadata.withId(TERSE_NAME).name(NAME)
.extensions(EXTENSIONS)
.addVersion("3.4")
.addDefaultVersion("3.5"),
new ModelicaHandler());
}
}
| 900 | 30.068966 | 79 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/ModelicaHandler.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica;
import net.sourceforge.pmd.lang.AbstractPmdLanguageVersionHandler;
import net.sourceforge.pmd.lang.ast.Parser;
import net.sourceforge.pmd.lang.modelica.ast.ModelicaParser;
public class ModelicaHandler extends AbstractPmdLanguageVersionHandler {
@Override
public Parser getParser() {
return new ModelicaParser();
}
}
| 472 | 23.894737 | 79 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/ast/ASTStoredDefinition.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.ast;
import net.sourceforge.pmd.lang.ast.AstInfo;
import net.sourceforge.pmd.lang.ast.Parser.ParserTask;
import net.sourceforge.pmd.lang.ast.RootNode;
import net.sourceforge.pmd.lang.modelica.resolver.CompositeName;
/**
* A representation of a Modelica source code file.
*/
public class ASTStoredDefinition extends AbstractModelicaNode implements RootNode {
private boolean hasBOM = false;
private AstInfo<ASTStoredDefinition> astInfo;
ASTStoredDefinition(int id) {
super(id);
}
@Override
protected <P, R> R acceptModelicaVisitor(ModelicaVisitor<? super P, ? extends R> visitor, P data) {
return visitor.visit(this, data);
}
void markHasBOM() {
hasBOM = true;
}
@Override
public AstInfo<ASTStoredDefinition> getAstInfo() {
return astInfo;
}
ASTStoredDefinition makeTaskInfo(ParserTask task) {
this.astInfo = new AstInfo<>(task, this);
return this;
}
/**
* Returns whether this source file contains Byte Order Mark.
*/
public boolean getHasBOM() {
return hasBOM;
}
@Override
public void jjtClose() {
super.jjtClose();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < getNumChildren(); ++i) {
AbstractModelicaNode child = (AbstractModelicaNode) getChild(i);
if (child instanceof ASTWithinClause) {
if (sb.length() > 0) {
sb.append(CompositeName.NAME_COMPONENT_SEPARATOR);
}
sb.append(child.getImage());
}
}
setImage(sb.toString());
}
}
| 1,779 | 25.567164 | 103 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/ast/ModelicaParserVisitor.java | /*
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.ast;
import net.sourceforge.pmd.annotation.DeprecatedUntil700;
import net.sourceforge.pmd.lang.ast.Node;
/**
* Backwards-compatibility only.
*
* @deprecated Use {@link ModelicaVisitor}
*/
@Deprecated
@DeprecatedUntil700
public interface ModelicaParserVisitor extends ModelicaVisitor<Object, Object> {
@Override
default Object visitNode(Node node, Object param) {
node.children().forEach(c -> c.acceptVisitor(this, param));
return param;
}
}
| 607 | 22.384615 | 80 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/ast/Helper.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.ast;
import java.util.List;
import net.sourceforge.pmd.lang.modelica.resolver.ResolutionResult;
import net.sourceforge.pmd.lang.modelica.resolver.ResolvableEntity;
final class Helper {
private Helper() {
}
// For Rule Designer
static String getResolvedTo(ResolutionResult<ResolvableEntity> result) {
List<ResolvableEntity> decls = result.getBestCandidates();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < decls.size(); ++i) {
if (i != 0) {
sb.append(", ");
}
sb.append(decls.get(i).getDescriptiveName());
}
return sb.toString();
}
}
| 794 | 26.413793 | 79 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/ast/ASTRenamingImportClause.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.ast;
import net.sourceforge.pmd.lang.modelica.resolver.ModelicaDeclaration;
import net.sourceforge.pmd.lang.modelica.resolver.ModelicaScope;
import net.sourceforge.pmd.lang.modelica.resolver.ResolutionContext;
import net.sourceforge.pmd.lang.modelica.resolver.ResolutionResult;
import net.sourceforge.pmd.lang.modelica.resolver.ResolutionState;
public final class ASTRenamingImportClause extends AbstractModelicaImportClause {
private ASTName importWhat;
private String renamedTo;
ASTRenamingImportClause(int id) {
super(id);
}
@Override
protected <P, R> R acceptModelicaVisitor(ModelicaVisitor<? super P, ? extends R> visitor, P data) {
return visitor.visit(this, data);
}
@Override
public void jjtClose() {
super.jjtClose();
importWhat = getFirstChildOfType(ASTName.class);
renamedTo = getFirstChildOfType(ASTSimpleName.class).getImage();
}
@Override
protected ResolutionResult<ModelicaDeclaration> getCacheableImportSources(ResolutionState state, ModelicaScope scope) {
return scope.safeResolveLexically(ModelicaDeclaration.class, state, importWhat.getCompositeName());
}
@Override
protected void fetchImportedClassesFromSource(ResolutionContext result, ModelicaDeclaration source, String simpleName) {
if (renamedTo.equals(simpleName)) {
result.addCandidate(source);
}
}
@Override
public boolean isQualified() {
return true;
}
}
| 1,633 | 31.039216 | 124 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/ast/ASTUnqualifiedImportClause.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.ast;
import net.sourceforge.pmd.lang.modelica.resolver.CompositeName;
import net.sourceforge.pmd.lang.modelica.resolver.InternalModelicaResolverApi;
import net.sourceforge.pmd.lang.modelica.resolver.ModelicaDeclaration;
import net.sourceforge.pmd.lang.modelica.resolver.ModelicaScope;
import net.sourceforge.pmd.lang.modelica.resolver.ResolutionContext;
import net.sourceforge.pmd.lang.modelica.resolver.ResolutionResult;
import net.sourceforge.pmd.lang.modelica.resolver.ResolutionState;
import net.sourceforge.pmd.lang.modelica.resolver.Watchdog;
public final class ASTUnqualifiedImportClause extends AbstractModelicaImportClause {
private ASTName importFromWhere;
ASTUnqualifiedImportClause(int id) {
super(id);
}
@Override
protected <P, R> R acceptModelicaVisitor(ModelicaVisitor<? super P, ? extends R> visitor, P data) {
return visitor.visit(this, data);
}
@Override
public void jjtClose() {
super.jjtClose();
importFromWhere = getFirstChildOfType(ASTName.class);
}
@Override
protected ResolutionResult<ModelicaDeclaration> getCacheableImportSources(ResolutionState state, ModelicaScope scope) {
return scope.safeResolveLexically(ModelicaDeclaration.class, state, importFromWhere.getCompositeName());
}
@Override
protected void fetchImportedClassesFromSource(ResolutionContext result, ModelicaDeclaration source, String simpleName) throws Watchdog.CountdownException {
result.watchdogTick();
InternalModelicaResolverApi.resolveFurtherNameComponents(source, result, CompositeName.create(simpleName));
}
@Override
public boolean isQualified() {
return false;
}
}
| 1,843 | 35.156863 | 159 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/ast/ASTName.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.ast;
import net.sourceforge.pmd.lang.modelica.resolver.CompositeName;
import net.sourceforge.pmd.lang.modelica.resolver.ResolutionResult;
import net.sourceforge.pmd.lang.modelica.resolver.ResolutionState;
import net.sourceforge.pmd.lang.modelica.resolver.ResolvableEntity;
public final class ASTName extends AbstractModelicaNode implements ResolvableModelicaNode {
private String[] nameComponents;
private ResolutionResult<ResolvableEntity> resolutionCandidates;
private boolean absolute = false;
ASTName(int id) {
super(id);
}
@Override
protected <P, R> R acceptModelicaVisitor(ModelicaVisitor<? super P, ? extends R> visitor, P data) {
return visitor.visit(this, data);
}
@Override
public void jjtClose() {
super.jjtClose();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < getNumChildren(); ++i) {
if (i != 0 || absolute) {
sb.append('.');
}
sb.append(((ASTSimpleName) getChild(i)).getImage());
}
setImage(sb.toString());
nameComponents = new String[getNumChildren()];
for (int i = 0; i < getNumChildren(); ++i) {
nameComponents[i] = getChild(i).getImage();
}
}
void markAbsolute() {
absolute = true;
}
/**
* Returns whether this reference is absolute (starts with a dot), such as
* <code>.Modelica.Blocks.Continuous.Filter</code>.
*/
public boolean isAbsolute() {
return absolute;
}
/**
* Returns a {@link CompositeName} object representing a lexical reference contained in this node.
*/
public CompositeName getCompositeName() {
return CompositeName.create(absolute, nameComponents);
}
/**
* Returns resolution candidates for the referred entity.
*
* We do not decide on entity type on behalf of the rule code, since this may introduce false negatives.
*/
@Override
public ResolutionResult<ResolvableEntity> getResolutionCandidates() {
if (resolutionCandidates == null) {
resolutionCandidates = getMostSpecificScope().safeResolveLexically(ResolvableEntity.class, ResolutionState.forType(), getCompositeName());
}
return resolutionCandidates;
}
// For Rule Designer
public String getResolvedTo() {
return Helper.getResolvedTo(getResolutionCandidates());
}
}
| 2,577 | 30.439024 | 150 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/ast/ASTClassDefinition.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.ast;
import net.sourceforge.pmd.lang.modelica.resolver.ModelicaClassSpecialization;
public class ASTClassDefinition extends AbstractModelicaNode {
private ASTClassPrefixes prefixes;
private ModelicaClassSpecialization specialization;
private ModelicaClassSpecifierNode specifier;
ASTClassDefinition(int id) {
super(id);
}
public boolean isPartial() {
return prefixes.getFirstChildOfType(ASTPartialClause.class) != null;
}
public boolean isEncapsulated() {
return getFirstChildOfType(ASTEncapsulatedClause.class) != null;
}
public ModelicaClassSpecialization getSpecialization() {
return specialization;
}
public ModelicaClassSpecifierNode getClassSpecifier() {
return specifier;
}
private void checkSpecialization(Class<? extends ModelicaNode> clauseClass, ModelicaClassSpecialization restriction) {
if (prefixes.getFirstChildOfType(clauseClass) != null) {
assert specialization == null;
specialization = restriction;
}
}
private void detectSpecialization() {
checkSpecialization(ASTClassClause.class, ModelicaClassSpecialization.CLASS);
checkSpecialization(ASTModelClause.class, ModelicaClassSpecialization.MODEL);
checkSpecialization(ASTRecordClause.class, ModelicaClassSpecialization.RECORD);
checkSpecialization(ASTOperatorRecordClause.class, ModelicaClassSpecialization.OPERATOR_RECORD);
checkSpecialization(ASTBlockClause.class, ModelicaClassSpecialization.BLOCK);
checkSpecialization(ASTConnectorClause.class, ModelicaClassSpecialization.CONNECTOR);
checkSpecialization(ASTExpandableConnectorClause.class, ModelicaClassSpecialization.EXPANDABLE_CONNECTOR);
checkSpecialization(ASTTypeClause.class, ModelicaClassSpecialization.TYPE);
checkSpecialization(ASTPackageClause.class, ModelicaClassSpecialization.PACKAGE);
checkSpecialization(ASTOperatorClause.class, ModelicaClassSpecialization.OPERATOR);
ASTFunctionClause functionOrNull = prefixes.getFirstChildOfType(ASTFunctionClause.class);
if (functionOrNull != null) {
boolean isPure = functionOrNull.getFirstChildOfType(ASTPureClause.class) != null;
boolean isOperator = functionOrNull.getFirstChildOfType(ASTOperatorClause.class) != null;
assert specialization == null;
specialization = ModelicaClassSpecialization.getFunctionSpecialization(isPure, isOperator);
}
assert specialization != null;
}
@Override
public void jjtClose() {
super.jjtClose();
prefixes = getFirstChildOfType(ASTClassPrefixes.class);
specifier = getFirstChildOfType(ASTClassSpecifier.class).getFirstChildOfType(ModelicaClassSpecifierNode.class);
detectSpecialization();
}
@Override
protected <P, R> R acceptModelicaVisitor(ModelicaVisitor<? super P, ? extends R> visitor, P data) {
return visitor.visit(this, data);
}
}
| 3,165 | 41.213333 | 122 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/ast/ASTDerClassSpecifier.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.ast;
public final class ASTDerClassSpecifier extends AbstractModelicaClassSpecifierNode {
ASTDerClassSpecifier(int id) {
super(id);
}
@Override
protected <P, R> R acceptModelicaVisitor(ModelicaVisitor<? super P, ? extends R> visitor, P data) {
return visitor.visit(this, data);
}
}
| 451 | 25.588235 | 103 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/ast/ModelicaParserVisitorAdapter.java | /*
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.ast;
import net.sourceforge.pmd.annotation.DeprecatedUntil700;
@Deprecated
@DeprecatedUntil700
public class ModelicaParserVisitorAdapter extends ModelicaVisitorBase<Object, Object> implements ModelicaParserVisitor {
}
| 351 | 24.142857 | 120 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/ast/Visibility.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.ast;
public enum Visibility {
UNSPEC(),
PRIVATE(),
PROTECTED(),
PUBLIC()
}
| 223 | 16.230769 | 79 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/ast/ASTSimpleShortClassSpecifier.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.ast;
import net.sourceforge.pmd.lang.modelica.resolver.InternalModelicaResolverApi;
import net.sourceforge.pmd.lang.modelica.resolver.ModelicaClassType;
public final class ASTSimpleShortClassSpecifier extends AbstractModelicaClassSpecifierNode {
ASTSimpleShortClassSpecifier(int id) {
super(id);
}
@Override
protected <P, R> R acceptModelicaVisitor(ModelicaVisitor<? super P, ? extends R> visitor, P data) {
return visitor.visit(this, data);
}
@Override
public void populateExtendsAndImports(ModelicaClassType classTypeDeclaration) {
super.populateExtendsAndImports(classTypeDeclaration);
InternalModelicaResolverApi.addExtendToClass(
classTypeDeclaration,
Visibility.UNSPEC,
getFirstChildOfType(ASTName.class).getCompositeName()
);
}
}
| 992 | 32.1 | 103 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/ast/ASTExtendingLongClassSpecifier.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.ast;
import net.sourceforge.pmd.lang.modelica.resolver.ModelicaClassType;
public final class ASTExtendingLongClassSpecifier extends AbstractModelicaClassSpecifierNode {
ASTExtendingLongClassSpecifier(int id) {
super(id);
}
@Override
protected <P, R> R acceptModelicaVisitor(ModelicaVisitor<? super P, ? extends R> visitor, P data) {
return visitor.visit(this, data);
}
@Override
public void populateExtendsAndImports(ModelicaClassType classTypeDeclaration) {
super.populateExtendsAndImports(classTypeDeclaration);
pushExtendsAndImports(classTypeDeclaration, getFirstChildOfType(ASTComposition.class));
// TODO
}
}
| 821 | 30.615385 | 103 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/ast/ASTMultipleDefinitionImportClause.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.ast;
import java.util.HashSet;
import java.util.Set;
import net.sourceforge.pmd.lang.modelica.resolver.CompositeName;
import net.sourceforge.pmd.lang.modelica.resolver.InternalModelicaResolverApi;
import net.sourceforge.pmd.lang.modelica.resolver.ModelicaDeclaration;
import net.sourceforge.pmd.lang.modelica.resolver.ModelicaScope;
import net.sourceforge.pmd.lang.modelica.resolver.ResolutionContext;
import net.sourceforge.pmd.lang.modelica.resolver.ResolutionResult;
import net.sourceforge.pmd.lang.modelica.resolver.ResolutionState;
import net.sourceforge.pmd.lang.modelica.resolver.Watchdog;
public final class ASTMultipleDefinitionImportClause extends AbstractModelicaImportClause {
private ASTName importFrom;
private Set<String> importedNames = new HashSet<>();
ASTMultipleDefinitionImportClause(int id) {
super(id);
}
@Override
protected <P, R> R acceptModelicaVisitor(ModelicaVisitor<? super P, ? extends R> visitor, P data) {
return visitor.visit(this, data);
}
@Override
public void jjtClose() {
super.jjtClose();
importFrom = getFirstChildOfType(ASTName.class);
ASTImportList importList = getFirstChildOfType(ASTImportList.class);
for (int i = 0; i < importList.getNumChildren(); ++i) {
ASTSimpleName namePart = (ASTSimpleName) importList.getChild(i);
importedNames.add(namePart.getImage());
}
}
@Override
protected ResolutionResult<ModelicaDeclaration> getCacheableImportSources(ResolutionState state, ModelicaScope scope) {
return scope.safeResolveLexically(ModelicaDeclaration.class, state, importFrom.getCompositeName());
}
@Override
protected void fetchImportedClassesFromSource(ResolutionContext result, ModelicaDeclaration source, String simpleName) throws Watchdog.CountdownException {
if (importedNames.contains(simpleName)) {
InternalModelicaResolverApi.resolveFurtherNameComponents(source, result, CompositeName.create(simpleName));
}
}
@Override
public boolean isQualified() {
return true;
}
}
| 2,259 | 36.666667 | 159 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/ast/AbstractModelicaClassSpecifierNode.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.ast;
import net.sourceforge.pmd.lang.modelica.resolver.InternalModelicaResolverApi;
import net.sourceforge.pmd.lang.modelica.resolver.ModelicaClassType;
/**
* Common parent for class-specifier nodes, see {@link ModelicaClassSpecifierNode} for public API.
*/
abstract class AbstractModelicaClassSpecifierNode extends AbstractModelicaNode implements ModelicaClassSpecifierNode {
AbstractModelicaClassSpecifierNode(int id) {
super(id);
}
@Override
public void jjtClose() {
super.jjtClose();
setImage(getFirstChildOfType(ASTSimpleName.class).getImage());
}
/**
* Fills in the class definition with <code>extends</code> and <code>import</code> clauses contained in this AST node.
*
* @param classTypeDeclaration a class declaration object corresponding to this AST node
*/
void populateExtendsAndImports(ModelicaClassType classTypeDeclaration) {
// by default, do nothing
}
private void pushExtendsAndImportsFromList(ModelicaClassType classTypeDeclaration, ASTElementList listNode) {
for (int i = 0; i < listNode.getNumChildren(); ++i) {
AbstractModelicaNode child = (AbstractModelicaNode) listNode.getChild(i);
if (child instanceof ASTExtendsClause) {
InternalModelicaResolverApi.addExtendToClass(
classTypeDeclaration,
listNode.getVisibility(),
child.getFirstChildOfType(ASTName.class).getCompositeName()
);
}
if (child instanceof ASTImportClause) {
InternalModelicaResolverApi.addImportToClass(
classTypeDeclaration,
listNode.getVisibility(),
child.getFirstChildOfType(ModelicaImportClause.class)
);
}
}
}
void pushExtendsAndImports(ModelicaClassType classTypeDeclaration, ASTComposition composition) {
for (int i = 0; i < composition.getNumChildren(); ++i) {
ModelicaNode maybeElementList = composition.getChild(i);
if (maybeElementList instanceof ASTElementList) {
pushExtendsAndImportsFromList(classTypeDeclaration, (ASTElementList) maybeElementList);
}
}
}
@Override
public String getSimpleClassName() {
return getImage();
}
}
| 2,541 | 36.940299 | 122 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/ast/ModelicaVisitorBase.java | /*
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.ast;
import net.sourceforge.pmd.lang.ast.AstVisitorBase;
/**
* Base implementation of {@link ModelicaVisitor}.
*/
public abstract class ModelicaVisitorBase<P, R> extends AstVisitorBase<P, R> implements ModelicaVisitor<P, R> {
}
| 363 | 23.266667 | 111 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/ast/ModelicaParser.java | /*
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.ast;
import net.sourceforge.pmd.benchmark.TimeTracker;
import net.sourceforge.pmd.lang.ast.ParseException;
import net.sourceforge.pmd.lang.ast.impl.javacc.CharStream;
import net.sourceforge.pmd.lang.ast.impl.javacc.JavaccTokenDocument.TokenDocumentBehavior;
import net.sourceforge.pmd.lang.ast.impl.javacc.JjtreeParserAdapter;
import net.sourceforge.pmd.lang.modelica.resolver.ModelicaSymbolFacade;
public class ModelicaParser extends JjtreeParserAdapter<ASTStoredDefinition> {
private static final TokenDocumentBehavior TOKEN_BEHAVIOR = new TokenDocumentBehavior(ModelicaTokenKinds.TOKEN_NAMES);
@Override
protected TokenDocumentBehavior tokenBehavior() {
return TOKEN_BEHAVIOR;
}
@Override
protected ASTStoredDefinition parseImpl(CharStream cs, ParserTask task) throws ParseException {
ASTStoredDefinition root = new ModelicaParserImpl(cs).StoredDefinition().makeTaskInfo(task);
TimeTracker.bench("Modelica symbols", () -> ModelicaSymbolFacade.process(root));
return root;
}
}
| 1,176 | 35.78125 | 122 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/ast/ASTSimpleLongClassSpecifier.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.ast;
import net.sourceforge.pmd.lang.modelica.resolver.ModelicaClassType;
public final class ASTSimpleLongClassSpecifier extends AbstractModelicaClassSpecifierNode {
ASTSimpleLongClassSpecifier(int id) {
super(id);
}
@Override
protected <P, R> R acceptModelicaVisitor(ModelicaVisitor<? super P, ? extends R> visitor, P data) {
return visitor.visit(this, data);
}
@Override
void populateExtendsAndImports(ModelicaClassType classTypeDeclaration) {
super.populateExtendsAndImports(classTypeDeclaration);
pushExtendsAndImports(classTypeDeclaration, getFirstChildOfType(ASTComposition.class));
}
}
| 792 | 30.72 | 103 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/ast/ModelicaNode.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.ast;
import net.sourceforge.pmd.annotation.DeprecatedUntil700;
import net.sourceforge.pmd.lang.ast.AstVisitor;
import net.sourceforge.pmd.lang.ast.impl.javacc.JjtreeNode;
import net.sourceforge.pmd.lang.modelica.resolver.ModelicaScope;
/**
* Public interface for all Modelica AST nodes.
*/
public interface ModelicaNode extends JjtreeNode<ModelicaNode> {
/**
* @deprecated Use {@link #acceptVisitor(AstVisitor, Object)}
*/
@DeprecatedUntil700
@Deprecated
default Object jjtAccept(ModelicaParserVisitor visitor, Object data) {
return acceptVisitor(visitor, data);
}
/**
* Returns the lexical scope this node is contained in.
*/
ModelicaScope getContainingScope();
/**
* Returns the most specific lexical scope naturally associated with this node.
*
* @return the scope defined by this node itself or the same as {@link #getContainingScope()} otherwise
*/
ModelicaScope getMostSpecificScope();
}
| 1,119 | 26.317073 | 107 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/ast/ASTSingleDefinitionImportClause.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.ast;
import net.sourceforge.pmd.lang.modelica.resolver.ModelicaDeclaration;
import net.sourceforge.pmd.lang.modelica.resolver.ModelicaScope;
import net.sourceforge.pmd.lang.modelica.resolver.ResolutionContext;
import net.sourceforge.pmd.lang.modelica.resolver.ResolutionResult;
import net.sourceforge.pmd.lang.modelica.resolver.ResolutionState;
public class ASTSingleDefinitionImportClause extends AbstractModelicaImportClause {
private ASTName importWhat;
private String importedName;
ASTSingleDefinitionImportClause(int id) {
super(id);
}
@Override
protected <P, R> R acceptModelicaVisitor(ModelicaVisitor<? super P, ? extends R> visitor, P data) {
return visitor.visit(this, data);
}
@Override
public void jjtClose() {
super.jjtClose();
importWhat = getFirstChildOfType(ASTName.class);
importedName = importWhat.getChild(importWhat.getNumChildren() - 1).getImage();
}
@Override
protected ResolutionResult<ModelicaDeclaration> getCacheableImportSources(ResolutionState state, ModelicaScope scope) {
return scope.safeResolveLexically(ModelicaDeclaration.class, state, importWhat.getCompositeName());
}
@Override
protected void fetchImportedClassesFromSource(ResolutionContext result, ModelicaDeclaration source, String simpleName) {
if (importedName.equals(simpleName)) {
result.addCandidate(source);
}
}
@Override
public boolean isQualified() {
return true;
}
}
| 1,664 | 31.647059 | 124 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/ast/ModelicaImportClause.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.ast;
public interface ModelicaImportClause extends ModelicaNode {
}
| 200 | 21.333333 | 79 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/ast/InternalModelicaNodeApi.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.ast;
import net.sourceforge.pmd.annotation.InternalApi;
import net.sourceforge.pmd.lang.modelica.resolver.ModelicaClassType;
import net.sourceforge.pmd.lang.modelica.resolver.ModelicaScope;
import net.sourceforge.pmd.lang.modelica.resolver.ResolutionContext;
import net.sourceforge.pmd.lang.modelica.resolver.Watchdog;
@InternalApi
public final class InternalModelicaNodeApi {
private InternalModelicaNodeApi() {}
public static void setNodeOwnScope(ModelicaNode node, ModelicaScope scope) {
((AbstractModelicaNode) node).setOwnScope(scope);
}
public static boolean isQualifiedImport(ModelicaImportClause importClause) {
return ((AbstractModelicaImportClause) importClause).isQualified();
}
public static void resolveImportedSimpleName(ModelicaImportClause importClause, ResolutionContext result, String simpleName) throws Watchdog.CountdownException {
((AbstractModelicaImportClause) importClause).resolveSimpleName(result, simpleName);
}
public static void populateExtendsAndImports(ModelicaClassSpecifierNode classNode, ModelicaClassType classTypeDeclaration) {
((AbstractModelicaClassSpecifierNode) classNode).populateExtendsAndImports(classTypeDeclaration);
}
}
| 1,371 | 40.575758 | 165 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/ast/AbstractModelicaNode.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.ast;
import net.sourceforge.pmd.lang.ast.AstVisitor;
import net.sourceforge.pmd.lang.ast.impl.javacc.AbstractJjtreeNode;
import net.sourceforge.pmd.lang.modelica.resolver.ModelicaScope;
/**
* Abstract base class for all nodes parsed by {@link ModelicaParser}.
*
* Please note that some of these nodes are autogenerated and placed to
* <code>pmd-modelica/target/generated-sources/javacc</code> by the build script. Those
* located here are deleted from autogenerated sources after build.
*
* @see ModelicaNode for public API.
*/
abstract class AbstractModelicaNode extends AbstractJjtreeNode<AbstractModelicaNode, ModelicaNode> implements ModelicaNode {
private ModelicaScope ownScope;
AbstractModelicaNode(int id) {
super(id);
}
@Override // override to make protected member accessible to parser
protected void setImage(String image) {
super.setImage(image);
}
@Override
@SuppressWarnings("unchecked")
public final <P, R> R acceptVisitor(AstVisitor<? super P, ? extends R> visitor, P data) {
if (visitor instanceof ModelicaVisitor) {
return acceptModelicaVisitor((ModelicaVisitor<? super P, ? extends R>) visitor, data);
}
return visitor.cannotVisit(this, data);
}
protected abstract <P, R> R acceptModelicaVisitor(ModelicaVisitor<? super P, ? extends R> visitor, P data);
@Override
public String getXPathNodeName() {
return getClass().getSimpleName().substring(3);
}
@Override
public ModelicaScope getContainingScope() {
return getParent().getMostSpecificScope();
}
@Override
public ModelicaScope getMostSpecificScope() {
if (ownScope == null) {
return getContainingScope();
} else {
return ownScope;
}
}
/**
* For resolver, set the lexical scope defined by this node, if any.
*
* @param scope Scope defined by this specific node
*/
void setOwnScope(ModelicaScope scope) {
ownScope = scope;
}
}
| 2,185 | 28.540541 | 124 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/ast/ASTWithinClause.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.ast;
public final class ASTWithinClause extends AbstractModelicaNode {
ASTWithinClause(int id) {
super(id);
}
@Override
protected <P, R> R acceptModelicaVisitor(ModelicaVisitor<? super P, ? extends R> visitor, P data) {
return visitor.visit(this, data);
}
@Override
public void jjtClose() {
super.jjtClose();
ASTName name = getFirstChildOfType(ASTName.class);
if (name != null) {
setImage(name.getImage());
} else {
setImage("");
}
}
}
| 683 | 22.586207 | 103 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/ast/ModelicaClassSpecifierNode.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.ast;
/**
* Public API for class defining AST nodes.
*/
public interface ModelicaClassSpecifierNode extends ModelicaNode {
String getSimpleClassName();
}
| 291 | 21.461538 | 79 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/ast/ASTComponentReference.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.ast;
import net.sourceforge.pmd.lang.modelica.resolver.CompositeName;
import net.sourceforge.pmd.lang.modelica.resolver.ResolutionResult;
import net.sourceforge.pmd.lang.modelica.resolver.ResolutionState;
import net.sourceforge.pmd.lang.modelica.resolver.ResolvableEntity;
public final class ASTComponentReference extends AbstractModelicaNode implements ResolvableModelicaNode {
private String[] nameComponentsWithoutSubscripts;
private boolean absolute;
private ResolutionResult<ResolvableEntity> resolutionCandidates;
ASTComponentReference(int id) {
super(id);
}
void markAbsolute() {
absolute = true;
}
/**
* Returns whether this reference is absolute (starts with a dot), such as
* <code>y = .Modelica.Math.cos(x)</code>.
*/
boolean isAbsolute() {
return absolute;
}
/**
* Returns a {@link CompositeName} object representing the lexical reference with subscripts being ignored, if any.
*/
public CompositeName getCompositeNameWithoutSubscripts() {
return CompositeName.create(absolute, nameComponentsWithoutSubscripts);
}
/**
* Returns resolution candidates for the referred component (and <b>not</b> dereferencing its type, etc.).
*
* We do not decide on entity type on behalf of the rule code, since this may introduce false negatives.
*/
@Override
public ResolutionResult<ResolvableEntity> getResolutionCandidates() {
if (resolutionCandidates == null) {
resolutionCandidates = getMostSpecificScope().safeResolveLexically(ResolvableEntity.class, ResolutionState.forComponentReference(), getCompositeNameWithoutSubscripts());
}
return resolutionCandidates;
}
// For Rule Designer
public String getResolvedTo() {
return Helper.getResolvedTo(getResolutionCandidates());
}
@Override
protected <P, R> R acceptModelicaVisitor(ModelicaVisitor<? super P, ? extends R> visitor, P data) {
return visitor.visit(this, data);
}
@Override
public void jjtClose() {
super.jjtClose();
nameComponentsWithoutSubscripts = new String[getNumChildren()];
for (int i = 0; i < nameComponentsWithoutSubscripts.length; ++i) {
String name = getChild(i).getFirstChildOfType(ASTSimpleName.class).getImage();
nameComponentsWithoutSubscripts[i] = name;
}
}
}
| 2,564 | 33.662162 | 181 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/ast/ASTEnumerationShortClassSpecifier.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.ast;
public final class ASTEnumerationShortClassSpecifier extends AbstractModelicaClassSpecifierNode {
ASTEnumerationShortClassSpecifier(int id) {
super(id);
}
@Override
protected <P, R> R acceptModelicaVisitor(ModelicaVisitor<? super P, ? extends R> visitor, P data) {
return visitor.visit(this, data);
}
}
| 477 | 27.117647 | 103 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/ast/ResolvableModelicaNode.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.ast;
import net.sourceforge.pmd.lang.modelica.resolver.ResolutionResult;
/**
* A public API for resolving lexical references to class or components.
*/
public interface ResolvableModelicaNode extends ModelicaNode {
/**
* Tries to resolve the <b>declaration</b> of the referenced component.
*/
ResolutionResult getResolutionCandidates();
}
| 492 | 26.388889 | 79 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/ast/AbstractModelicaImportClause.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.ast;
import net.sourceforge.pmd.lang.modelica.resolver.ModelicaDeclaration;
import net.sourceforge.pmd.lang.modelica.resolver.ModelicaScope;
import net.sourceforge.pmd.lang.modelica.resolver.ResolutionContext;
import net.sourceforge.pmd.lang.modelica.resolver.ResolutionResult;
import net.sourceforge.pmd.lang.modelica.resolver.ResolutionState;
import net.sourceforge.pmd.lang.modelica.resolver.Watchdog;
/**
* Common internal machinery for various import clauses to describe themselves to resolver.
*/
abstract class AbstractModelicaImportClause extends AbstractModelicaNode implements ModelicaImportClause {
private ResolutionResult<ModelicaDeclaration> importSourcesCache;
AbstractModelicaImportClause(int id) {
super(id);
}
/**
* Some import clauses are considered "qualified", some "unqualified", the former being processed first
* while looking up some name. See "5.3.1 Simple Name Lookup" from MLS 3.4.
*
* @return Whether this kind of import is considered "qualified"
*/
abstract boolean isQualified();
/**
* A template method to be used by {@link #resolveSimpleName}. Usually used to fetch the lexically referenced
* class in the corresponding import statement.
*/
protected abstract ResolutionResult<ModelicaDeclaration> getCacheableImportSources(ResolutionState state, ModelicaScope scope);
/**
* A template method to be used by {@link #resolveSimpleName}. Usually used to try to fetch declarations for
* <code>simpleName</code> from particular <i>source</i> returned by {@link #getCacheableImportSources}.
*/
protected abstract void fetchImportedClassesFromSource(ResolutionContext result, ModelicaDeclaration source, String simpleName) throws Watchdog.CountdownException;
/**
* Tries to resolve the specified name via this import clause.
*
* @param result Resolution context
* @param simpleName Name to resolve
* @throws Watchdog.CountdownException if too many resolution steps were performed
*/
final void resolveSimpleName(ResolutionContext result, String simpleName) throws Watchdog.CountdownException {
// No need to re-resolve if already resolved successfully
if (importSourcesCache == null || importSourcesCache.wasTimedOut()) {
importSourcesCache = getCacheableImportSources(result.getState(), getMostSpecificScope().getParent());
}
for (ModelicaDeclaration source : importSourcesCache.getBestCandidates()) {
fetchImportedClassesFromSource(result, source, simpleName);
}
result.markHidingPoint();
for (ModelicaDeclaration source : importSourcesCache.getHiddenCandidates()) {
fetchImportedClassesFromSource(result, source, simpleName);
}
}
}
| 2,946 | 44.338462 | 167 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/ast/ASTElementList.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.ast;
public class ASTElementList extends AbstractModelicaNode {
private Visibility visibility;
ASTElementList(int id) {
super(id);
}
void setVisibility(Visibility visibility) {
this.visibility = visibility;
}
public Visibility getVisibility() {
return visibility;
}
@Override
protected <P, R> R acceptModelicaVisitor(ModelicaVisitor<? super P, ? extends R> visitor, P data) {
return visitor.visit(this, data);
}
}
| 622 | 22.074074 | 103 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/rule/ConnectUsingNonConnector.java | /*
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.rule;
import net.sourceforge.pmd.lang.modelica.rule.bestpractices.ConnectUsingNonConnectorRule;
/**
* @deprecated Use {@link ConnectUsingNonConnectorRule}
*/
@Deprecated
public class ConnectUsingNonConnector extends ConnectUsingNonConnectorRule {
}
| 385 | 21.705882 | 89 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/rule/AmbiguousResolutionRule.java | /*
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.rule;
/**
* @deprecated Use {@link net.sourceforge.pmd.lang.modelica.rule.bestpractices.AmbiguousResolutionRule}
*/
public class AmbiguousResolutionRule extends net.sourceforge.pmd.lang.modelica.rule.bestpractices.AmbiguousResolutionRule {
}
| 377 | 26 | 123 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/rule/AbstractModelicaRule.java | /*
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.rule;
import net.sourceforge.pmd.RuleContext;
import net.sourceforge.pmd.lang.ast.Node;
import net.sourceforge.pmd.lang.modelica.ast.ModelicaParserVisitor;
import net.sourceforge.pmd.lang.rule.AbstractRule;
/**
* Base class for rules for Modelica language.
*/
public abstract class AbstractModelicaRule extends AbstractRule implements ModelicaParserVisitor {
@Override
public void apply(Node target, RuleContext ctx) {
target.acceptVisitor(this, ctx);
}
}
| 612 | 25.652174 | 98 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/rule/bestpractices/AmbiguousResolutionRule.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.rule.bestpractices;
import net.sourceforge.pmd.lang.modelica.ast.ASTName;
import net.sourceforge.pmd.lang.modelica.resolver.ResolutionResult;
import net.sourceforge.pmd.lang.modelica.resolver.ResolvableEntity;
import net.sourceforge.pmd.lang.modelica.rule.AbstractModelicaRule;
public class AmbiguousResolutionRule extends AbstractModelicaRule {
@Override
public Object visit(ASTName node, Object data) {
ResolutionResult<ResolvableEntity> candidates = node.getResolutionCandidates();
if (candidates.isClashed()) {
StringBuilder sb = new StringBuilder();
sb.append("Candidate resolutions: ");
for (ResolvableEntity candidate: candidates.getBestCandidates()) {
sb.append(candidate.getDescriptiveName());
sb.append(", ");
}
addViolation(data, node, sb.substring(0, sb.length() - 2));
}
return super.visit(node, data);
}
}
| 1,089 | 37.928571 | 87 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/rule/bestpractices/ConnectUsingNonConnectorRule.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.rule.bestpractices;
import net.sourceforge.pmd.lang.modelica.ast.ASTComponentReference;
import net.sourceforge.pmd.lang.modelica.ast.ASTConnectClause;
import net.sourceforge.pmd.lang.modelica.resolver.ModelicaClassSpecialization;
import net.sourceforge.pmd.lang.modelica.resolver.ModelicaClassType;
import net.sourceforge.pmd.lang.modelica.resolver.ModelicaComponentDeclaration;
import net.sourceforge.pmd.lang.modelica.resolver.ResolutionResult;
import net.sourceforge.pmd.lang.modelica.resolver.ResolvableEntity;
import net.sourceforge.pmd.lang.modelica.rule.AbstractModelicaRule;
public class ConnectUsingNonConnectorRule extends AbstractModelicaRule {
private void reportIfViolated(ASTComponentReference ref, Object data) {
ResolutionResult<ResolvableEntity> resolution = ref.getResolutionCandidates();
if (!resolution.isUnresolved()) { // no false positive if not resolved at all
ResolvableEntity firstDecl = resolution.getBestCandidates().get(0);
if (firstDecl instanceof ModelicaComponentDeclaration) {
ModelicaComponentDeclaration componentDecl = (ModelicaComponentDeclaration) firstDecl;
ResolutionResult componentTypes = componentDecl.getTypeCandidates();
if (!componentTypes.isUnresolved()) {
if (componentTypes.getBestCandidates().get(0) instanceof ModelicaClassType) {
ModelicaClassType classDecl = (ModelicaClassType) componentTypes.getBestCandidates().get(0);
ModelicaClassSpecialization restriction = classDecl.getSpecialization();
if (!classDecl.isConnectorLike()) {
addViolation(data, ref, restriction.toString());
}
} else {
addViolation(data, ref, firstDecl.getDescriptiveName());
}
}
} else {
addViolation(data, ref, firstDecl.getDescriptiveName());
}
}
}
@Override
public Object visit(ASTConnectClause node, Object data) {
ASTComponentReference lhs = (ASTComponentReference) node.getChild(0);
ASTComponentReference rhs = (ASTComponentReference) node.getChild(1);
reportIfViolated(lhs, data);
reportIfViolated(rhs, data);
return super.visit(node, data);
}
}
| 2,535 | 47.769231 | 116 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/resolver/ModelicaClassType.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.resolver;
/**
* A Modelica type that is defined as a <i>class</i> (i.e., class, package, model, etc.).
*/
public interface ModelicaClassType extends ModelicaType, ModelicaDeclaration, SubcomponentResolver {
/**
* Returns the class specialization (i.e., package, model, function, etc.)
*/
ModelicaClassSpecialization getSpecialization();
/**
* Returns whether this class is some kind of connector.
*/
boolean isConnectorLike();
/**
* Returns whether this class is encapsulated.
*/
boolean isEncapsulated();
/**
* Returns whether this class is partial.
*/
boolean isPartial();
/**
* Returns the scope defined by this class itself.
*/
ModelicaClassScope getClassScope();
}
| 898 | 23.972222 | 100 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/resolver/ResolutionState.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.resolver;
public final class ResolutionState {
private final Watchdog watchdog;
private boolean constantsOnly;
private ResolutionState(boolean constantsOnly) {
watchdog = new Watchdog(1000);
this.constantsOnly = constantsOnly;
}
public static ResolutionState forType() {
return new ResolutionState(true);
}
public static ResolutionState forComponentReference() {
return new ResolutionState(false);
}
void tick() throws Watchdog.CountdownException {
watchdog.decrement();
}
public boolean needRecurseInto(ModelicaComponentDeclaration component) {
return !constantsOnly || component.getVariability() == ModelicaComponentDeclaration.ComponentVariability.CONSTANT;
}
public ResolutionContext createContext() {
return new ResolutionContext(this);
}
}
| 996 | 26.694444 | 122 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/resolver/ModelicaSourceFileScope.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.resolver;
import net.sourceforge.pmd.lang.modelica.ast.ASTStoredDefinition;
/**
* A scope corresponding to some specific Modelica source code file.
*/
public final class ModelicaSourceFileScope extends AbstractModelicaScope {
private final String fileFQCN;
private final String[] packageComponents;
ModelicaSourceFileScope(ASTStoredDefinition node) {
fileFQCN = node.getImage();
if (fileFQCN.isEmpty()) {
packageComponents = new String[0];
} else {
packageComponents = fileFQCN.split("\\.");
}
}
/**
* Resolve <code>name</code> as if not accounting for <code>fileFQCN</code> (as if it would be empty).
*/
void lookupLocally(ResolutionContext result, CompositeName name) throws Watchdog.CountdownException {
if (name.isEmpty()) {
// TODO technically, here we should return an implicit package...
return;
}
result.watchdogTick();
String firstName = name.getHead();
CompositeName furtherNames = name.getTail();
for (ModelicaDeclaration decl: getDirectlyDeclared(firstName)) {
ResolutionContext tmpContext = result.getState().createContext();
((ModelicaClassDeclaration) decl).lookupInInstanceScope(result, furtherNames);
// According to "5.2 Enclosing classes" from MLS 3.4, the order of definitions inside the unnamed
// enclosing class is unspecified, so handle name hiding with care.
result.accumulate(tmpContext.get(ResolvableEntity.class));
}
}
/**
* Resolve <code>name</code> accounting for <code>fileFQCN</code>. To be called from {@link RootScope}.
*/
void lookupGlobally(ResolutionContext result, CompositeName name) throws Watchdog.CountdownException {
result.watchdogTick();
CompositeName remainingNameComponents = name.matchPrefix(packageComponents);
if (remainingNameComponents != null) {
lookupLocally(result, remainingNameComponents);
}
}
@Override
public void resolveLexically(ResolutionContext result, CompositeName name) throws Watchdog.CountdownException {
if (!isInDefaultPackage()) {
// otherwise we would get it from the RootScope anyway
lookupLocally(result, name);
}
((AbstractModelicaScope) getParent()).resolveLexically(result, name);
}
@Override
public String getRepresentation() {
return "FILE";
}
public boolean isInDefaultPackage() {
return fileFQCN.isEmpty();
}
public String getFileFQCN() {
return fileFQCN;
}
}
| 2,797 | 33.975 | 115 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/resolver/ModelicaType.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.resolver;
/**
* Some Modelica <i>type</i> (either class or built-in type) that some component may have.
*/
public interface ModelicaType extends ResolvableEntity {
/**
* Returns short name of a type, such as "Real" or "Filter".
*/
String getSimpleTypeName();
/**
* Returns the fully-qualified name, when appropriate, or simple name for primitive types.
*/
String getFullTypeName();
}
| 555 | 25.47619 | 94 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/resolver/ResolvableEntity.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.resolver;
/**
* Interface for entities that can be looked up.
*/
public interface ResolvableEntity {
/**
* Returns some name to be shown to user in violation description.
*/
String getDescriptiveName();
}
| 357 | 21.375 | 79 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/resolver/ModelicaSymbolFacade.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.resolver;
import net.sourceforge.pmd.annotation.InternalApi;
import net.sourceforge.pmd.lang.modelica.ast.ASTStoredDefinition;
@InternalApi
public final class ModelicaSymbolFacade {
private ModelicaSymbolFacade() {
// util class
}
public static void process(ASTStoredDefinition node) {
ScopeAndDeclarationFinder sc = new ScopeAndDeclarationFinder();
node.acceptVisitor(sc, null);
}
}
| 559 | 24.454545 | 79 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/resolver/ModelicaBuiltinType.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.resolver;
/**
* Built-in Modelica types. There are only four <b>basic</b> variants: <code>Boolean</code>, <code>Integer</code>,
* <code>Real</code> and <code>String</code> but they can have modifications applied (such as min/max values),
* so do not introduce them as singletones for extendability in the future.
*/
public class ModelicaBuiltinType implements ModelicaType {
public enum BaseType {
BOOLEAN("Boolean"),
INTEGER("Integer"),
REAL("Real"),
STRING("String");
private final String name;
BaseType(String name) {
this.name = name;
}
String getName() {
return name;
}
@Override
public String toString() {
return name;
}
}
private final BaseType baseType;
ModelicaBuiltinType(BaseType tpe) {
baseType = tpe;
}
public BaseType getBaseType() {
return baseType;
}
@Override
public String getSimpleTypeName() {
return baseType.toString();
}
@Override
public String getFullTypeName() {
return baseType.toString();
}
@Override
public String getDescriptiveName() {
return getFullTypeName();
}
}
| 1,376 | 21.95 | 114 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/resolver/Watchdog.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.resolver;
/**
* A watchdog counter initialized with some value. Throws an exception after the specified {@link #decrement} calls.
*
* Is used to break possible resolution loops.
*/
public class Watchdog {
private int counter;
public static final class CountdownException extends Exception {
// no specific logic, just kind of marker
}
Watchdog(int initial) {
counter = initial;
}
void decrement() throws CountdownException {
counter -= 1;
if (counter < 0) {
throw new CountdownException();
}
}
}
| 715 | 22.866667 | 116 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/resolver/ModelicaClassSpecialization.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.resolver;
/**
* Enumerates "specialized kinds of classes" (package, model, connector, etc.) that define
* some restrictions and enhancements on what can be defined inside and how can they be used.
*
* See "4.6 Specialized classes" from MLS 3.4
*/
public enum ModelicaClassSpecialization {
CLASS("class"),
MODEL("model"),
RECORD("record"),
OPERATOR_RECORD("operator record"),
BLOCK("block"),
CONNECTOR("connector"),
EXPANDABLE_CONNECTOR("expandable connector"),
TYPE("type"),
PACKAGE("package"),
FUNCTION("function"),
PURE_FUNCTION("pure function"),
OPERATOR_FUNCTION("operator function"),
PURE_OPERATOR_FUNCTION("pure operator function"),
OPERATOR("operator");
private String name;
ModelicaClassSpecialization(String name) {
this.name = name;
}
public static ModelicaClassSpecialization getFunctionSpecialization(boolean isPure, boolean isOperator) {
if (isPure) {
return isOperator ? PURE_OPERATOR_FUNCTION : PURE_FUNCTION;
} else {
return isOperator ? OPERATOR_FUNCTION : FUNCTION;
}
}
@Override
public String toString() {
return name;
}
}
| 1,335 | 26.833333 | 109 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/resolver/SubcomponentResolver.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.resolver;
/**
* This interface represents something that, being looked up by some prefix of composite name,
* may resolve further name parts. Lexically, this is represented by a dot-notation.
*
* Please do not confuse this with {@link ModelicaScope} representing <b>lexical</b> scope,
* that resolves names as if they are written in the corresponding part of the source file.
*/
public interface SubcomponentResolver {
/**
* Resolves `<code>name</code> as if resolving subcomponents through the type of base component
*
* @param state The resolution state
* @param name The name to resolve
* @return The resolved declarations
*/
<T extends ResolvableEntity> ResolutionResult<T> safeResolveComponent(Class<T> clazz, ResolutionState state, CompositeName name);
}
| 938 | 38.125 | 133 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/resolver/AbstractModelicaScope.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.resolver;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* Internal base class for Modelica lexical scopes, see {@link ModelicaScope} for the public API.
*/
abstract class AbstractModelicaScope implements ModelicaScope {
private AbstractModelicaScope parent;
private final List<ModelicaDeclaration> declarations = new ArrayList<>();
private final Map<String, List<ModelicaDeclaration>> declarationsByName = new HashMap<>();
void setParent(AbstractModelicaScope scope) {
parent = scope;
}
@Override
public ModelicaScope getParent() {
return parent;
}
void addDeclaration(ModelicaDeclaration declaration) {
String name = declaration.getSimpleDeclarationName();
declarations.add(declaration);
if (!declarationsByName.containsKey(name)) {
declarationsByName.put(name, new ArrayList<>());
}
declarationsByName.get(name).add(declaration);
}
@Override
public List<ModelicaDeclaration> getContainedDeclarations() {
return Collections.unmodifiableList(declarations);
}
List<ModelicaDeclaration> getDirectlyDeclared(String simpleName) {
List<ModelicaDeclaration> result = declarationsByName.get(simpleName);
if (result != null) {
return result;
} else {
return Collections.emptyList();
}
}
/**
* Resolves a name as if it is written inside this lexical scope in a file.
*/
abstract void resolveLexically(ResolutionContext result, CompositeName name) throws Watchdog.CountdownException;
@Override
public <T extends ResolvableEntity> ResolutionResult<T> safeResolveLexically(Class<T> clazz, ResolutionState state, CompositeName name) {
ResolutionContext result = state.createContext();
try {
resolveLexically(result, name);
} catch (Watchdog.CountdownException e) {
result.markTtlExceeded();
}
return result.get(clazz);
}
protected abstract String getRepresentation();
// For testing purposes
String getNestingRepresentation() {
ModelicaScope parentScope = getParent();
String prefix = "";
if (parentScope != null) {
prefix = ((AbstractModelicaScope) parentScope).getNestingRepresentation();
}
return prefix + "#" + getRepresentation();
}
@Override
public RootScope getRoot() {
return getParent().getRoot();
}
@Override
public String toString() {
return getRepresentation();
}
}
| 2,792 | 29.692308 | 141 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/resolver/AbstractModelicaDeclaration.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.resolver;
/**
* Internal base class for Modelica declarations, see ${@link ModelicaDeclaration} for public API.
*/
abstract class AbstractModelicaDeclaration implements ModelicaDeclaration {
/**
* Resolves further name components, supposing previous ones resolved to this declaration.
*
* @param result Where to place resolution results
* @param name Further name parts to resolve
* @throws Watchdog.CountdownException if too many resolution steps were performed
*/
abstract void resolveFurtherNameComponents(ResolutionContext result, CompositeName name) throws Watchdog.CountdownException;
}
| 767 | 37.4 | 128 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/resolver/ResolutionResult.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.resolver;
import java.util.List;
/**
* This class represents a resolution result of some (possibly composite) name inside some context
*
* Usage of special interface instead of plain <code>List<ModelicaDeclaration></code> allows returning some additional information
* such as "layers" of resolved symbol (for example, these 10 symbols are obviously hidden, but these two are equally
* relevant, thus introducing name clash). Moreover, more diagnostic information can be introduced in the future
* without changing lots of source code.
*/
public interface ResolutionResult<A extends ResolvableEntity> {
/**
* Returns declarations that are supposed to be taken by the Modelica compiler (normally, exactly one match).
*
* @return A declaration(s) to be used. Every result not consisting of exactly one declaration signifies
* a possible error-severity issue in the source to be analysed.
*/
List<A> getBestCandidates();
/**
* Returns declarations that are definitely hidden by some others.
*
* Non empty returned collection may signify either warning-grade issue in the source to be analysed
* or just some peculiarities of the particular Modelica code design, it depends.
*
* @return A collections of definitely hidden resolution candidates
*/
List<A> getHiddenCandidates();
/**
* Whether any resolution candidate exists.
*
* @return getBestCandidates().size != 0
*/
boolean isUnresolved();
/**
* Whether the symbol resolver found multiple equally relevant resolution candidates.
*
* @return getBestCandidates().size > 1
*/
boolean isClashed();
/**
* Whether the symbol resolver found any symbol suspiciously hidden by other ones.
*
* @return getHiddenCandidates().size != 0
*/
boolean hasHiddenResults();
/**
* During resolution, loops may occur. This leads to timing out the resolution and (possibly) partial results.
*
* This method may return `true` even if other ones return some non-empty result. It merely signifies that
* the results may depend on particular limit on the number of resolution steps.
*
* @return Whether resolution was timed out
*/
boolean wasTimedOut();
}
| 2,436 | 35.373134 | 136 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/resolver/ModelicaScope.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.resolver;
import java.util.List;
/**
* A <b>lexical</b> scope of Modelica code.
* That is, a component declaration does not have one, it is its type that does (but these may be resolved to multiple
* classes or not resolved at all, these classes generally reside in other files, etc.)
*
* Please do not confuse this with {@link SubcomponentResolver} that represents "view from the outside" on something
* possibly looked up from other file via component reference.
*/
public interface ModelicaScope {
/**
* Returns the declarations that were lexically declared in this scope.
*/
List<ModelicaDeclaration> getContainedDeclarations();
/**
* Resolves a name as if it is written inside this lexical scope in a file.
*/
<T extends ResolvableEntity> ResolutionResult<T> safeResolveLexically(Class<T> clazz, ResolutionState state, CompositeName name);
/**
* Returns the parent (i.e., containing) scope.
*/
ModelicaScope getParent();
RootScope getRoot();
}
| 1,150 | 31.885714 | 133 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/resolver/ScopeAndDeclarationFinder.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.resolver;
import java.util.ArrayDeque;
import java.util.Deque;
import net.sourceforge.pmd.lang.modelica.ast.ASTClassDefinition;
import net.sourceforge.pmd.lang.modelica.ast.ASTComponentDeclaration;
import net.sourceforge.pmd.lang.modelica.ast.ASTStoredDefinition;
import net.sourceforge.pmd.lang.modelica.ast.InternalModelicaNodeApi;
import net.sourceforge.pmd.lang.modelica.ast.ModelicaNode;
import net.sourceforge.pmd.lang.modelica.ast.ModelicaParserVisitorAdapter;
class ScopeAndDeclarationFinder extends ModelicaParserVisitorAdapter {
private final Deque<AbstractModelicaScope> scopes = new ArrayDeque<>();
ScopeAndDeclarationFinder() {
scopes.push(new RootScope());
}
private void pushScope(ModelicaNode node, AbstractModelicaScope ownScope) {
AbstractModelicaScope prevTop = scopes.peek();
ownScope.setParent(prevTop);
scopes.push(ownScope);
InternalModelicaNodeApi.setNodeOwnScope(node, ownScope);
}
private void createClassDeclaration(ASTClassDefinition node) {
ModelicaScope containingScope = node.getParent().getMostSpecificScope();
ModelicaClassDeclaration declaration = new ModelicaClassDeclaration(node);
((AbstractModelicaScope) containingScope).addDeclaration(declaration);
pushScope(node, new ModelicaClassScope(declaration));
}
private void createFileDeclaration(ASTStoredDefinition node) {
RootScope rootScope = (RootScope) scopes.peek();
ModelicaSourceFileScope scope = new ModelicaSourceFileScope(node);
rootScope.addSourceFile(scope);
pushScope(node, scope);
}
private void createComponentDeclaration(ASTComponentDeclaration node) {
ModelicaComponentDeclaration declaration = new ModelicaComponentDeclaration(node);
declaration.setContainingScope((ModelicaClassScope) scopes.peek());
((AbstractModelicaScope) node.getMostSpecificScope()).addDeclaration(declaration);
}
@Override
public Object visit(ASTStoredDefinition node, Object data) {
createFileDeclaration(node);
return cont(node);
}
@Override
public Object visit(ASTClassDefinition node, Object data) {
createClassDeclaration(node);
return cont(node);
}
@Override
public Object visit(ASTComponentDeclaration node, Object data) {
createComponentDeclaration(node);
return super.visit(node, data);
}
private Object cont(ModelicaNode node) {
super.visitModelicaNode(node, null);
scopes.pop();
return null;
}
}
| 2,716 | 34.75 | 90 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/resolver/InternalModelicaResolverApi.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.resolver;
import net.sourceforge.pmd.annotation.InternalApi;
import net.sourceforge.pmd.lang.modelica.ast.ModelicaImportClause;
import net.sourceforge.pmd.lang.modelica.ast.Visibility;
@InternalApi
public final class InternalModelicaResolverApi {
private InternalModelicaResolverApi() {}
public static void addImportToClass(ModelicaClassType classTypeDeclaration, Visibility visibility, ModelicaImportClause clause) {
((ModelicaClassDeclaration) classTypeDeclaration).addImport(visibility, clause);
}
public static void addExtendToClass(ModelicaClassType classTypeDeclaration, Visibility visibility, CompositeName extendedClass) {
((ModelicaClassDeclaration) classTypeDeclaration).addExtends(visibility, extendedClass);
}
public static void resolveFurtherNameComponents(ModelicaDeclaration declaration, ResolutionContext result, CompositeName name) throws Watchdog.CountdownException {
((AbstractModelicaDeclaration) declaration).resolveFurtherNameComponents(result, name);
}
}
| 1,166 | 42.222222 | 167 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/resolver/ModelicaClassDeclaration.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.resolver;
import java.util.ArrayList;
import java.util.List;
import net.sourceforge.pmd.lang.modelica.ast.ASTClassDefinition;
import net.sourceforge.pmd.lang.modelica.ast.InternalModelicaNodeApi;
import net.sourceforge.pmd.lang.modelica.ast.ModelicaClassSpecifierNode;
import net.sourceforge.pmd.lang.modelica.ast.ModelicaImportClause;
import net.sourceforge.pmd.lang.modelica.ast.Visibility;
/**
* Internal representation of a declared Modelica class, see {@link ModelicaClassType} for public API.
*/
class ModelicaClassDeclaration extends AbstractModelicaDeclaration implements ModelicaClassType {
private ModelicaClassScope ownScope;
private boolean encapsulated;
private boolean partial;
private ModelicaClassSpecialization specialization;
private String simpleName;
private final List<ModelicaImportClause> imports = new ArrayList<>();
private final List<CompositeName> extendedClasses = new ArrayList<>();
private List<ModelicaClassScope> resolvedExtends;
ModelicaClassDeclaration(ASTClassDefinition node) {
encapsulated = node.isEncapsulated();
partial = node.isPartial();
specialization = node.getSpecialization();
ModelicaClassSpecifierNode classNode = node.getClassSpecifier();
simpleName = classNode.getSimpleClassName();
InternalModelicaNodeApi.populateExtendsAndImports(classNode, this);
}
/**
* To be called by a corresponding AST node describing itself
*/
void addImport(Visibility visibility, ModelicaImportClause clause) {
// TODO handle visibility
imports.add(clause);
}
/**
* To be called by a corresponding AST node describing itself
*/
void addExtends(Visibility visibility, CompositeName extendedClass) {
// TODO handle visibility
assert resolvedExtends == null;
extendedClasses.add(extendedClass);
}
private List<ModelicaClassScope> getResolvedExtends(ResolutionState lazyInitState) {
if (resolvedExtends == null) {
ResolutionContext ctx = lazyInitState.createContext();
try {
for (CompositeName name : extendedClasses) {
ctx.watchdogTick();
((AbstractModelicaScope) ownScope.getParent()).resolveLexically(ctx, name);
}
} catch (Watchdog.CountdownException e) {
ctx.markTtlExceeded();
}
resolvedExtends = new ArrayList<>();
for (ModelicaType decl: ctx.getTypes().getBestCandidates()) {
if (decl instanceof ModelicaClassDeclaration) {
resolvedExtends.add(((ModelicaClassDeclaration) decl).getClassScope());
}
}
}
return resolvedExtends;
}
@Override
public <T extends ResolvableEntity> ResolutionResult<T> safeResolveComponent(Class<T> clazz, ResolutionState state, CompositeName name) {
ResolutionContext result = state.createContext();
try {
lookupInInstanceScope(result, name);
} catch (Watchdog.CountdownException e) {
result.markTtlExceeded();
}
return result.get(clazz);
}
/**
* Looks up the first part of composite name in imported classes (either qualified or unqualified)
*
* @param state resolution parameters
* @param firstName a name to resolve
* @param qualified whether we are looking at qualified imports or unqualified ones
* @return List of candidate resolutions
* @throws Watchdog.CountdownException if too many lookup steps were performed
*/
private ResolutionResult<ModelicaDeclaration> lookupImported(ResolutionState state, String firstName, boolean qualified) throws Watchdog.CountdownException {
state.tick();
ResolutionContext result = state.createContext();
for (final ModelicaImportClause importClause: imports) {
ResolutionContext subResult = state.createContext();
if (InternalModelicaNodeApi.isQualifiedImport(importClause) == qualified) {
InternalModelicaNodeApi.resolveImportedSimpleName(importClause, subResult, firstName);
}
result.accumulate(subResult.getDeclaration());
}
return result.getDeclaration();
}
/**
* Look up composite name inside this instance scope (and not above).
* This method itself implements corresponding part of "5.3.1 Simple Name Lookup" of MLS 3.4.
*
* @param result an object to place results to
* @param name a name to look up
* @throws Watchdog.CountdownException in too many lookup steps were performed
*/
void lookupInInstanceScope(ResolutionContext result, CompositeName name) throws Watchdog.CountdownException {
if (name.isEmpty()) {
result.addCandidate(this);
return;
}
String firstName = name.getHead();
CompositeName furtherParts = name.getTail();
result.watchdogTick();
// Otherwise, lookup...
// ... among declared names of the class
for (ModelicaDeclaration decl: ownScope.getDirectlyDeclared(firstName)) {
lookupInInstanceScopeFurtherParts(result, decl, furtherParts);
}
result.markHidingPoint();
// ... and from inherited, too
for (ModelicaClassScope extendedClass: getResolvedExtends(result.getState())) {
for (ModelicaDeclaration inheritedDecl: extendedClass.getDirectlyDeclared(firstName)) {
lookupInInstanceScopeFurtherParts(result, inheritedDecl, furtherParts);
}
}
result.markHidingPoint();
// ... using qualified imports
ResolutionResult<ModelicaDeclaration> qualifiedImports = lookupImported(result.getState(), firstName, true);
for (ModelicaDeclaration importedDecl: qualifiedImports.getBestCandidates()) {
lookupInInstanceScopeFurtherParts(result, importedDecl, furtherParts);
}
result.markHidingPoint();
for (ModelicaDeclaration importedDecl: qualifiedImports.getHiddenCandidates()) {
lookupInInstanceScopeFurtherParts(result, importedDecl, furtherParts);
}
result.markHidingPoint();
// ... then using unqualified imports
ResolutionResult<ModelicaDeclaration> unqualifiedImports = lookupImported(result.getState(), firstName, false);
for (ModelicaDeclaration importedDecl: unqualifiedImports.getBestCandidates()) {
lookupInInstanceScopeFurtherParts(result, importedDecl, furtherParts);
}
result.markHidingPoint();
for (ModelicaDeclaration importedDecl: unqualifiedImports.getHiddenCandidates()) {
lookupInInstanceScopeFurtherParts(result, importedDecl, furtherParts);
}
}
/**
* Recurse into the first resolved element of composite name
*
* This method itself implements the "5.3.2 Composite Name Lookup" of MLS 3.4 with the first step
* being made by `lookupInInstanceScope`.
*
* @param result an object to place results to
* @param resolvedSimpleName a declaration found when resolving the very first part of composite name
* @param furtherParts an unresolved "tail" of a composite name
* @throws Watchdog.CountdownException if too many resolution steps were performed
*/
private void lookupInInstanceScopeFurtherParts(ResolutionContext result, ModelicaDeclaration resolvedSimpleName, CompositeName furtherParts) throws Watchdog.CountdownException {
result.watchdogTick();
if (furtherParts.isEmpty()) {
result.addCandidate(resolvedSimpleName);
return;
}
if (resolvedSimpleName instanceof ModelicaComponentDeclaration) {
ModelicaComponentDeclaration component = (ModelicaComponentDeclaration) resolvedSimpleName;
if (result.getState().needRecurseInto(component)) {
ResolutionResult<ModelicaType> componentTypes = component.getTypeCandidates();
for (ModelicaType tpe : componentTypes.getBestCandidates()) {
if (tpe instanceof ModelicaClassDeclaration) {
((ModelicaClassDeclaration) tpe).lookupInInstanceScope(result, furtherParts);
}
}
result.markHidingPoint();
for (ModelicaType tpe : componentTypes.getHiddenCandidates()) {
if (tpe instanceof ModelicaClassDeclaration) {
((ModelicaClassDeclaration) tpe).lookupInInstanceScope(result, furtherParts);
}
}
}
} else if (resolvedSimpleName instanceof ModelicaClassDeclaration) {
ModelicaClassDeclaration classDecl = (ModelicaClassDeclaration) resolvedSimpleName;
classDecl.lookupInInstanceScope(result, furtherParts);
} else {
throw new IllegalArgumentException("Can recurse into class or component only");
}
}
void setOwnScope(ModelicaClassScope scope) {
ownScope = scope;
}
@Override
public ModelicaClassSpecialization getSpecialization() {
return specialization;
}
@Override
public boolean isConnectorLike() {
return specialization == ModelicaClassSpecialization.CONNECTOR || specialization == ModelicaClassSpecialization.EXPANDABLE_CONNECTOR;
}
@Override
public boolean isEncapsulated() {
return encapsulated;
}
@Override
public boolean isPartial() {
return partial;
}
@Override
public ModelicaScope getContainingScope() {
return ownScope.getParent();
}
@Override
public ModelicaClassScope getClassScope() {
return ownScope;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
if (encapsulated) {
sb.append("encapsulated ");
}
if (partial) {
sb.append("partial ");
}
sb.append(specialization.toString());
sb.append(' ');
sb.append(simpleName);
return sb.toString();
}
@Override
void resolveFurtherNameComponents(ResolutionContext result, CompositeName name) throws Watchdog.CountdownException {
lookupInInstanceScope(result, name);
}
@Override
public String getSimpleDeclarationName() {
return simpleName;
}
@Override
public String getSimpleTypeName() {
return simpleName;
}
@Override
public String getFullTypeName() {
return ownScope.getFullyQualifiedClassName();
}
@Override
public String getDescriptiveName() {
return getFullTypeName();
}
}
| 10,959 | 38.142857 | 181 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/resolver/RootScope.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.resolver;
import java.util.ArrayList;
import java.util.List;
/**
* A pseudo lexical scope corresponding to "unnamed enclosing class" for top-level entities.
* See "5.2 Enclosing Classes" from MLS 3.4.
*
* Unlike in MLS, this class aggregates <b>source file scopes</b>, not the top-level entities themselves.
*/
public final class RootScope extends AbstractModelicaScope {
private final List<ModelicaSourceFileScope> sourceFiles = new ArrayList<>();
void addSourceFile(ModelicaSourceFileScope sourceFile) {
sourceFiles.add(sourceFile);
}
void resolveBuiltin(ResolutionContext result, CompositeName name) {
if (!name.isEmpty() && name.getTail().isEmpty()) {
String simpleName = name.getHead();
for (ModelicaBuiltinType.BaseType tpe: ModelicaBuiltinType.BaseType.values()) {
if (tpe.getName().equals(simpleName)) {
result.addCandidate(new ModelicaBuiltinType(tpe));
}
}
}
}
@Override
public void resolveLexically(ResolutionContext result, CompositeName name) throws Watchdog.CountdownException {
CompositeName nameToLookup = CompositeName.ROOT_PSEUDO_NAME.equals(name.getHead()) ? name.getTail() : name;
resolveBuiltin(result, name);
for (ModelicaSourceFileScope sourceFile: sourceFiles) {
ResolutionContext tmpContext = result.getState().createContext();
sourceFile.lookupGlobally(tmpContext, nameToLookup);
// According to "5.2 Enclosing classes" from MLS 3.4, the order of definitions inside the unnamed
// enclosing class is unspecified, so handle name hiding with care.
result.accumulate(tmpContext.get(ResolvableEntity.class));
}
}
@Override
public RootScope getRoot() {
return this;
}
@Override
public String toString() {
return "<implicit root scope>";
}
@Override
public String getRepresentation() {
return "ROOT";
}
}
| 2,165 | 33.935484 | 115 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/resolver/CompositeName.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.resolver;
/**
* An immutable composite name representation for use in "pattern matching style".
*
* Supports lightweight splitting into first element and "tail" (everything else).
*/
public final class CompositeName {
private static final CompositeName NIL = new CompositeName(null, null);
static final String ROOT_PSEUDO_NAME = "";
public static final String NAME_COMPONENT_SEPARATOR = ".";
private String head;
private CompositeName tail;
private CompositeName(String head, CompositeName tail) {
this.head = head;
this.tail = tail;
}
private static CompositeName create(String[] components, int startIndex, int total, boolean isAbsolute) {
if (isAbsolute) {
return new CompositeName(ROOT_PSEUDO_NAME, create(components, startIndex, total, false));
} else if (startIndex == total) {
return NIL;
} else {
return new CompositeName(components[startIndex], create(components, startIndex + 1, total, false));
}
}
public static CompositeName create(boolean isAbsolute, String[] components) {
return create(components, 0, components.length, isAbsolute);
}
public static CompositeName create(boolean isAbsolute, String[] components, int prefixLength) {
return create(components, 0, prefixLength, isAbsolute);
}
public static CompositeName create(String simpleName) {
return new CompositeName(simpleName, NIL);
}
public boolean isEmpty() {
return head == null;
}
public String getHead() {
return head;
}
public CompositeName getTail() {
return tail;
}
private CompositeName matchPrefix(String[] prefix, int currentIndex) {
if (currentIndex == prefix.length) {
return this;
} else if (prefix[currentIndex].equals(head) && tail != null) {
return tail.matchPrefix(prefix, currentIndex + 1);
} else {
return null;
}
}
/**
* Tries to match the <code>prefix</code> argument with the first elements of this name
*
* @return the remaining elements on success or null on failure
*/
public CompositeName matchPrefix(String[] prefix) {
return matchPrefix(prefix, 0);
}
@Override
public String toString() {
if (isEmpty()) {
return "Nil";
} else {
return head + "::" + tail.toString();
}
}
}
| 2,611 | 29.022989 | 111 | java |
pmd | pmd-master/pmd-modelica/src/main/java/net/sourceforge/pmd/lang/modelica/resolver/ModelicaDeclaration.java | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.modelica.resolver;
/**
* Some Modelica entity that is explicitly declared with some name inside some lexical scope.
*/
public interface ModelicaDeclaration extends ResolvableEntity {
/**
* Returns the name of a declaration, such as "RealInput".
*/
String getSimpleDeclarationName();
/**
* Returns the scope in which this symbol is declared.
*/
ModelicaScope getContainingScope();
}
| 545 | 25 | 93 | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.