feat(spoon-smpl): initial support for the semantic patch language (Credits: Mikael Forsberg)

spoon-smpl/README.md

@@ -0,0 +1,8 @@
+# spoon-smpl
+
+This module aims to implement support for (a variant/subset of) [SmPL](https://en.wikipedia.org/wiki/Coccinelle_(software)#Semantic_Patch_Language "Wikipedia entry").
+
+Papers:
+* [SmPL: A Domain-Specific Language for Specifying Collateral Evolutions in Linux Device Drivers](http://coccinelle.lip6.fr/papers/ercim.pdf)
+* [A Foundation for Flow-Based Program Matching Using Temporal Logic and Model Checking](http://coccinelle.lip6.fr/papers/popl09.pdf)
+* [Semantic Patches for Java Program Transformation](https://drops.dagstuhl.de/opus/volltexte/2019/10814/pdf/LIPIcs-ECOOP-2019-22.pdf)

spoon-smpl/pom.xml

@@ -0,0 +1,93 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>fr.inria.gforge.spoon</groupId>
+    <artifactId>spoon-smpl</artifactId>
+    <version>0.0.1</version>
+    <licenses>
+        <license>
+            <name>The MIT license</name>
+            <url>http://www.opensource.org/licenses/mit-license.php</url>
+            <distribution>repo</distribution>
+        </license>
+    </licenses>
+    <parent>
+        <groupId>fr.inria.gforge.spoon</groupId>
+        <artifactId>spoon-pom</artifactId>
+        <version>1.0</version>
+        <relativePath>../spoon-pom</relativePath>
+    </parent>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.3</version>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-checkstyle-plugin</artifactId>
+                <version>3.1.0</version>
+                <configuration>
+                    <failsOnError>true</failsOnError>
+                    <configLocation>../checkstyle.xml</configLocation>
+                    <consoleOutput>true</consoleOutput>
+                </configuration>
+                <executions>
+                    <execution>
+                        <phase>verify</phase>
+                        <goals>
+                            <goal>checkstyle</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+        <pluginManagement>
+            <plugins>
+                <plugin>
+                    <groupId>com.mycila</groupId>
+                    <artifactId>license-maven-plugin</artifactId>
+                    <configuration>
+                        <header>LICENSE.txt</header>
+                        <basedir>src</basedir>
+                        <includes>
+                            <include>main/java/**</include>
+                        </includes>
+                    </configuration>
+                    <executions>
+                        <execution>
+                            <goals>
+                                <goal>check</goal>
+                            </goals>
+                        </execution>
+                    </executions>
+                </plugin>
+            </plugins>
+        </pluginManagement>
+    </build>
+    <dependencies>
+        <dependency>
+            <groupId>fr.inria.gforge.spoon</groupId>
+            <artifactId>spoon-core</artifactId>
+            <version>8.1.0-SNAPSHOT</version>
+        </dependency>
+        <dependency>
+            <groupId>fr.inria.gforge.spoon</groupId>
+            <artifactId>control-flow</artifactId>
+            <version>0.0.1</version>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.11</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+</project>

spoon-smpl/smpl_grammar.txt

@@ -0,0 +1,68 @@
+TODO: markdownify this file
+
+First milestone SmPL grammar:
+
+    Adapted from http://coccinelle.lip6.fr/docs/main_grammar.pdf
+
+
+
+    Note: This grammar is incomplete as it does not cover dot modifiers <...> and <+...+>,
+          pattern disjunction (p | ... | p) and conjunction (p && ... && p)
+
+          These constructs are to be part of the first milestone but could not be
+          trivially lifted from the official grammar PDF as they are buried in the
+          C-specific parts of that grammar.
+
+
+
+    program        ::= include_cocci* changeset+
+
+    include_cocci  ::= #include string
+                     | using string                        patch-local isomorphism definitions?
+                     | using pathToIsoFile
+                 //  | virtual id (,id)*
+
+    changeset      ::= metavariables transformation
+                 //  | script_metavariables script_code
+
+    metavariables  ::= @@ metadecl* @@ | @ rulename @ metadecl* @@
+
+    // rulename    ::= id [extends id] [depends on] [scope] dep [iso] [disable-iso] [exists] [rulekind]
+    rulename       ::= id
+
+    metadecl ::= identifier ids ;
+               | type ids ;
+               | expression [list] ids ;
+               | statement [list] ids ;
+               | constant ids ;
+               | JavaType ids ;         
+               // too much removed to include here
+
+    ids ::= pmid (, pmid)*
+    pmid ::= id | mid
+    mid ::= rulename_id.id
+
+    transformation ::= OPTDOTSEQ(top, when)
+
+    top ::= java_expr | java_decl_stmt+ | java_fundecl          this is where the java lives
+
+    when ::= when != when_code
+        // | when any                     lifting shortest path restriction
+        // | when strict                  applicable to error states (how are these determined?)
+           | when exists                  not all paths need to match
+           | when forall                  all paths must match the complete rule
+        // | when true != expr
+        // | when false != expr
+
+
+    OPTDOTSEQ(grammar, when) = [... (when)*] grammar (... (when)* grammar)* [... (when)*]
+
+
+
+
+    Notable omissions in first milestone:
+
+        dots in method calls: foo(...)
+        "when any" lifting of shortest-path restriction for dots
+        "fresh identifier" metavariables for code generation
+        constraints/regexes on metavariable ids

spoon-smpl/src/main/java/spoon/smpl/BranchLabel.java

@@ -0,0 +1,97 @@
+package spoon.smpl;
+
+import spoon.reflect.code.CtIf;
+import spoon.reflect.declaration.CtElement;
+import spoon.smpl.formula.BranchPattern;
+import spoon.smpl.formula.Predicate;
+import spoon.smpl.pattern.PatternBuilder;
+import spoon.smpl.pattern.PatternMatcher;
+import spoon.smpl.pattern.PatternNode;
+
+import java.util.Map;
+
+/**
+ * A BranchLabel is a Label used to associate states with CtElement code
+ * elements that can be matched using BranchPattern Formula elements.
+ */
+public class BranchLabel implements Label {
+    /**
+     * Create a new BranchLabel.
+     * @param cond Condition element of a branch statement element such as CtIf
+     */
+    public BranchLabel(CtElement cond) {
+        CtElement parent = cond.getParent(); // throws ParentNotInitializedException
+
+        boolean ok = false;
+
+        // check for supported type of branch element, more supported types to come
+        if (parent instanceof CtIf) {
+            ok = true;
+        }
+
+        if (!ok) {
+            throw new IllegalArgumentException("Invalid condition parent");
+        }
+
+        this.cond = cond;
+
+        PatternBuilder builder = new PatternBuilder();
+        cond.accept(builder);
+        this.condPattern = builder.getResult();
+
+        this.parameters = null;
+    }
+
+    /**
+     * Test whether the label matches the given predicate.
+     * @param obj Predicate to test
+     * @return True if the predicate is a StatementPattern element whose Pattern matches the code exactly once, false otherwise.
+     */
+    public boolean matches(Predicate obj) {
+        if (obj instanceof BranchPattern) {
+            BranchPattern bp = (BranchPattern) obj;
+
+            if (!bp.getBranchType().isInstance(cond.getParent())) {
+                return false;
+            }
+
+            PatternMatcher matcher = new PatternMatcher(bp.getConditionPattern());
+            condPattern.accept(matcher);
+            parameters = matcher.getParameters();
+            return matcher.getResult() && bp.processParameterBindings(parameters);
+        } else {
+            return false;
+        }
+    }
+
+    @Override
+    public Map<String, Object> getMatchedParameters() {
+        return parameters;
+    }
+
+    @Override
+    public void reset() {
+        parameters = null;
+    }
+
+    /**
+     * Get the code element.
+     * @return The code element
+     */
+    public CtElement getCondition() {
+        return cond;
+    }
+
+    /**
+     * The branch condition element.
+     */
+    private CtElement cond;
+
+    /**
+     * The pattern corresponding to the branch condition element.
+     * Part of temporary substitute for spoon.pattern.
+     */
+    private PatternNode condPattern;
+
+    private Map<String, Object> parameters;
+}

spoon-smpl/src/main/java/spoon/smpl/CFGModel.java

@@ -0,0 +1,115 @@
+package spoon.smpl;
+
+import fr.inria.controlflow.BranchKind;
+import fr.inria.controlflow.ControlFlowGraph;
+import spoon.reflect.declaration.CtElement;
+import spoon.smpl.formula.BranchPattern;
+
+import java.util.*;
+
+/**
+ * A CFGModel builds a CTL model from a given CFG.
+ */
+public class CFGModel implements Model {
+    /**
+     * Create a new CTL model from a given CFG.
+     * @param cfg The ControlFlowGraph to use as a model, must have been simplified
+     */
+    public CFGModel(ControlFlowGraph cfg) {
+        if (cfg.findNodesOfKind(BranchKind.BLOCK_BEGIN).size() > 0) {
+            throw new IllegalArgumentException("The CFG must be simplified (see ControlFlowGraph::simplify)");
+        }
+
+        this.cfg = cfg;
+
+        states = new ArrayList<Integer>();
+        successors = new HashMap<Integer, List<Integer>>();
+        labels = new HashMap<Integer, List<Label>>();
+
+        cfg.vertexSet().forEach(node -> {
+            int state = node.getId();
+
+            // Add a state ID for each vertex ID and prepare lists of successors and labels
+            states.add(state);
+            successors.put(state, new ArrayList<Integer>());
+            labels.put(state, new ArrayList<Label>());
+
+            // Add successors
+            cfg.outgoingEdgesOf(node).forEach(edge -> {
+                successors.get(state).add(edge.getTargetNode().getId());
+            });
+
+            // Add self-loop on exit node
+            if (node.getKind() == BranchKind.EXIT) {
+                successors.get(state).add(state);
+            }
+
+            CtElement stmt = node.getStatement();
+
+            // Add label
+            if (stmt != null) {
+                switch (node.getKind()) {
+                    case BRANCH:
+                        labels.get(state).add(new BranchLabel(stmt));
+                        break;
+                    case STATEMENT:
+                        labels.get(state).add(new StatementLabel(stmt));
+                        break;
+                    default:
+                        break;
+                }
+            }
+        });
+    }
+
+    /**
+     * @return the set of state IDs in the model
+     */
+    @Override
+    public List<Integer> getStates() {
+        return states;
+    }
+
+    /**
+     * @param state Parent state
+     * @return the set of immediate successors of the given state
+     */
+    @Override
+    public List<Integer> getSuccessors(int state) {
+        return successors.get(state);
+    }
+
+    /**
+     * @param state Target state
+     * @return the set of labels associated with the given state
+     */
+    @Override
+    public List<Label> getLabels(int state) {
+        return labels.get(state);
+    }
+
+    /**
+     * @return the Control Flow Graph used to generate the model
+     */
+    public ControlFlowGraph getCfg() { return cfg; }
+
+    /**
+     * The Control Flow Graph used to generate the model.
+     */
+    private ControlFlowGraph cfg;
+
+    /**
+     * The set of state IDs.
+     */
+    private List<Integer> states;
+
+    /**
+     * The set of immediate successors.
+     */
+    private Map<Integer, List<Integer>> successors;
+
+    /**
+     * The set of state labels.
+     */
+    private Map<Integer, List<Label>> labels;
+}