diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/cpd/ScalaTokenizer.java b/pmd-scala/src/main/java/net/sourceforge/pmd/cpd/ScalaTokenizer.java
index 38a813592b..0bb15eaa86 100644
--- a/pmd-scala/src/main/java/net/sourceforge/pmd/cpd/ScalaTokenizer.java
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/cpd/ScalaTokenizer.java
@@ -106,9 +106,8 @@ public class ScalaTokenizer implements Tokenizer {
             boolean skip = false;
             if (token.text() != null) {
                 // skip any token that is whitespaces
-                skip |= token instanceof Token.Space || token instanceof Token.Tab
-                        || token instanceof Token.CR || token instanceof Token.LF
-                        || token instanceof Token.FF || token instanceof Token.LFLF;
+                skip |= token instanceof Token.Space || token instanceof Token.Tab || token instanceof Token.CR
+                        || token instanceof Token.LF || token instanceof Token.FF || token instanceof Token.LFLF;
             }
             return skip;
         }
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ScalaParser.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ScalaParser.java
index 677f8d54f5..cf8e668c61 100644
--- a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ScalaParser.java
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ScalaParser.java
@@ -16,12 +16,11 @@ import net.sourceforge.pmd.lang.ParserOptions;
 import net.sourceforge.pmd.lang.TokenManager;
 import net.sourceforge.pmd.lang.ast.Node;
 import net.sourceforge.pmd.lang.ast.ParseException;
-import net.sourceforge.pmd.lang.scala.ast.ASTSourceNode;
-import net.sourceforge.pmd.lang.scala.ast.ScalaWrapperNode;
+import net.sourceforge.pmd.lang.scala.ast.ScalaTreeBuilder;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTSource;
 
 import scala.meta.Dialect;
 import scala.meta.Source;
-import scala.meta.Tree;
 import scala.meta.inputs.Input;
 import scala.meta.internal.parsers.ScalametaParser;
 
@@ -33,8 +32,6 @@ import scala.meta.internal.parsers.ScalametaParser;
 public class ScalaParser extends AbstractParser {
     private final Dialect dialect;
 
-    private Map<Tree, ScalaWrapperNode> nodeCache = new HashMap<>();
-
     /**
      * Create a parser using the given Scala Dialect and set of parser options.
      * 
@@ -55,7 +52,6 @@ public class ScalaParser extends AbstractParser {
 
     @Override
     public Node parse(String fileName, Reader source) throws ParseException {
-        nodeCache.clear();
         Input.VirtualFile virtualFile;
         try {
             String sourceString = IOUtils.toString(source);
@@ -64,30 +60,7 @@ public class ScalaParser extends AbstractParser {
             throw new ParseException(e);
         }
         Source src = new ScalametaParser(virtualFile, dialect).parseSource();
-        ASTSourceNode srcNode = new ASTSourceNode(this, src);
-        nodeCache.put(src, srcNode);
-        return srcNode;
-    }
-
-    /**
-     * Creates a wrapper around the given node so that we can interact with PMD
-     * systems using the underlying scala node.
-     * 
-     * @param scalaNode
-     *            a node from Scala's parsing
-     * @return A Java-wrapped version of the given node, using a cache if this
-     *         has been previously wrapped, or null, if the given node is null
-     */
-    public ScalaWrapperNode wrapNode(Tree scalaNode) {
-        if (scalaNode == null) {
-            return null;
-        }
-        ScalaWrapperNode node = nodeCache.get(scalaNode);
-        if (node == null) {
-            node = new ScalaWrapperNode(this, scalaNode);
-            nodeCache.put(scalaNode, node);
-        }
-        return node;
+        return (ASTSource) new ScalaTreeBuilder().build(src);
     }
 
     @Override
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/ASTSourceNode.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/ASTSourceNode.java
deleted file mode 100644
index 64041842f4..0000000000
--- a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/ASTSourceNode.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/**
- * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
- */
-
-package net.sourceforge.pmd.lang.scala.ast;
-
-import net.sourceforge.pmd.lang.ast.RootNode;
-import net.sourceforge.pmd.lang.scala.ScalaParser;
-
-import scala.meta.Source;
-
-/**
- * The root node for a Scala AST.
- */
-public class ASTSourceNode extends ScalaWrapperNode implements RootNode {
-
-    /**
-     * Create a new root node wrapper for the Scala root AST node.
-     * 
-     * @param scalaParser
-     *            the ScalaParser used to generate the node
-     * @param scalaNode
-     *            the scalaNode node to wrap
-     */
-    public ASTSourceNode(ScalaParser scalaParser, Source scalaNode) {
-        super(scalaParser, scalaNode);
-    }
-}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/DumpFacade.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/DumpFacade.java
index 1bbdbeab39..75fca35619 100644
--- a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/DumpFacade.java
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/DumpFacade.java
@@ -29,7 +29,7 @@ public class DumpFacade extends ScalaParserVisitorAdapter {
      * @param node
      *            the node to start with. Not necessarily a tree root.
      */
-    public void dump(Writer outWriter, String prefix, boolean shouldRecurse, ScalaNode node) {
+    public void dump(Writer outWriter, String prefix, boolean shouldRecurse, ScalaNode<?> node) {
         this.writer = outWriter instanceof PrintWriter ? (PrintWriter) outWriter : new PrintWriter(outWriter);
         this.recurse = shouldRecurse;
         this.visit(node, prefix);
@@ -37,7 +37,7 @@ public class DumpFacade extends ScalaParserVisitorAdapter {
     }
 
     @Override
-    public Object visit(ScalaNode node, Object data) {
+    public Object visit(ScalaNode<?> node, Object data) {
         dump(node, (String) data);
         if (recurse) {
             return super.visit(node, data + " ");
@@ -46,7 +46,7 @@ public class DumpFacade extends ScalaParserVisitorAdapter {
         }
     }
 
-    private void dump(ScalaNode node, String prefix) {
+    private void dump(ScalaNode<?> node, String prefix) {
         writer.print(prefix);
         writer.print(node.getXPathNodeName());
 
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/ScalaNode.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/ScalaNode.java
index 71cc2b4675..ea1faac4ea 100644
--- a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/ScalaNode.java
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/ScalaNode.java
@@ -11,8 +11,11 @@ import scala.meta.Tree;
 /**
  * A Base interface of a Scala Node. Defines several required methods of all
  * nodes.
+ * 
+ * @param <T>
+ *            The Scala node type that extends Scala's Tree trait
  */
-public interface ScalaNode extends Node {
+public interface ScalaNode<T extends Tree> extends Node {
     /**
      * Accept a visitor and traverse this node.
      * 
@@ -41,5 +44,5 @@ public interface ScalaNode extends Node {
      * 
      * @return the Scala Node for this node
      */
-    Tree getNode();
+    T getNode();
 }
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/ScalaParserVisitor.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/ScalaParserVisitor.java
index dcd2941908..bc8b41dac7 100644
--- a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/ScalaParserVisitor.java
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/ScalaParserVisitor.java
@@ -4,21 +4,138 @@
 
 package net.sourceforge.pmd.lang.scala.ast;
 
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTCase;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTCtorPrimary;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTCtorSecondary;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDeclDef;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDeclType;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDeclVal;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDeclVar;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDefnClass;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDefnDef;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDefnMacro;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDefnObject;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDefnTrait;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDefnType;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDefnVal;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDefnVar;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTEnumeratorGenerator;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTEnumeratorGuard;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTEnumeratorVal;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTImport;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTImporteeName;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTImporteeRename;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTImporteeUnimport;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTImporteeWildcard;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTImporter;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTInit;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitBoolean;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitByte;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitChar;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitDouble;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitFloat;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitInt;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitLong;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitNull;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitShort;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitString;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitSymbol;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitUnit;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModAbstract;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModAnnot;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModCase;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModContravariant;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModCovariant;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModFinal;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModImplicit;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModInline;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModLazy;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModOverride;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModPrivate;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModProtected;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModSealed;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModValParam;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModVarParam;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTNameAnonymous;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTNameIndeterminate;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatAlternative;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatBind;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatExtract;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatExtractInfix;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatInterpolate;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatSeqWildcard;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatTuple;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatTyped;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatVar;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatWildcard;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatXml;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPkg;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPkgObject;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTQuasi;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTSelf;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTSource;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTemplate;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermAnnotate;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermApply;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermApplyInfix;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermApplyType;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermApplyUnary;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermAscribe;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermAssign;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermBlock;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermDo;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermEta;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermFor;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermForYield;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermFunction;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermIf;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermInterpolate;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermMatch;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermName;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermNew;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermNewAnonymous;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermParam;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermPartialFunction;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermPlaceholder;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermRepeated;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermReturn;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermSelect;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermSuper;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermThis;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermThrow;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermTry;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermTryWithHandler;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermTuple;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermWhile;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermXml;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeAnd;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeAnnotate;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeApply;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeApplyInfix;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeBounds;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeByName;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeExistential;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeFunction;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeImplicitFunction;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeLambda;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeMethod;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeName;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeOr;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeParam;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypePlaceholder;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeProject;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeRefine;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeRepeated;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeSelect;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeSingleton;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeTuple;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeVar;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeWith;
+
 /**
  * A Visitor Pattern Interface for the Scala AST.
  */
 public interface ScalaParserVisitor {
-    /**
-     * Visit the Source Node (the root node of the tree).
-     * 
-     * @param node
-     *            the root node of the tree
-     * @param data
-     *            context-specific data
-     * @return context-specific data
-     */
-    Object visit(ASTSourceNode node, Object data);
-
     /**
      * Visit an arbitrary Scala Node (any node in the tree).
      * 
@@ -28,5 +145,269 @@ public interface ScalaParserVisitor {
      *            context-specific data
      * @return context-specific data
      */
-    Object visit(ScalaNode node, Object data);
+    Object visit(ScalaNode<?> node, Object data);
+
+    /**
+     * Visit the Source Node (the root node of the tree).
+     * 
+     * @param node
+     *            the root node of the tree
+     * @param data
+     *            context-specific data
+     * @return context-specific data
+     */
+    Object visit(ASTSource node, Object data);
+
+    Object visit(ASTCase node, Object data);
+
+    Object visit(ASTCtorPrimary node, Object data);
+
+    Object visit(ASTCtorSecondary node, Object data);
+
+    Object visit(ASTDeclDef node, Object data);
+
+    Object visit(ASTDeclType node, Object data);
+
+    Object visit(ASTDeclVal node, Object data);
+
+    Object visit(ASTDeclVar node, Object data);
+
+    Object visit(ASTDefnClass node, Object data);
+
+    Object visit(ASTDefnDef node, Object data);
+
+    Object visit(ASTDefnMacro node, Object data);
+
+    Object visit(ASTDefnObject node, Object data);
+
+    Object visit(ASTDefnTrait node, Object data);
+
+    Object visit(ASTDefnType node, Object data);
+
+    Object visit(ASTDefnVal node, Object data);
+
+    Object visit(ASTDefnVar node, Object data);
+
+    Object visit(ASTEnumeratorGenerator node, Object data);
+
+    Object visit(ASTEnumeratorGuard node, Object data);
+
+    Object visit(ASTEnumeratorVal node, Object data);
+
+    Object visit(ASTImport node, Object data);
+
+    Object visit(ASTImporteeName node, Object data);
+
+    Object visit(ASTImporteeRename node, Object data);
+
+    Object visit(ASTImporteeUnimport node, Object data);
+
+    Object visit(ASTImporteeWildcard node, Object data);
+
+    Object visit(ASTImporter node, Object data);
+
+    Object visit(ASTInit node, Object data);
+
+    Object visit(ASTLitBoolean node, Object data);
+
+    Object visit(ASTLitByte node, Object data);
+
+    Object visit(ASTLitChar node, Object data);
+
+    Object visit(ASTLitDouble node, Object data);
+
+    Object visit(ASTLitFloat node, Object data);
+
+    Object visit(ASTLitInt node, Object data);
+
+    Object visit(ASTLitLong node, Object data);
+
+    Object visit(ASTLitNull node, Object data);
+
+    Object visit(ASTLitShort node, Object data);
+
+    Object visit(ASTLitString node, Object data);
+
+    Object visit(ASTLitSymbol node, Object data);
+
+    Object visit(ASTLitUnit node, Object data);
+
+    Object visit(ASTModAbstract node, Object data);
+
+    Object visit(ASTModAnnot node, Object data);
+
+    Object visit(ASTModCase node, Object data);
+
+    Object visit(ASTModContravariant node, Object data);
+
+    Object visit(ASTModCovariant node, Object data);
+
+    Object visit(ASTModFinal node, Object data);
+
+    Object visit(ASTModImplicit node, Object data);
+
+    Object visit(ASTModInline node, Object data);
+
+    Object visit(ASTModLazy node, Object data);
+
+    Object visit(ASTModOverride node, Object data);
+
+    Object visit(ASTModPrivate node, Object data);
+
+    Object visit(ASTModProtected node, Object data);
+
+    Object visit(ASTModSealed node, Object data);
+
+    Object visit(ASTModValParam node, Object data);
+
+    Object visit(ASTModVarParam node, Object data);
+
+    Object visit(ASTNameAnonymous node, Object data);
+
+    Object visit(ASTNameIndeterminate node, Object data);
+
+    Object visit(ASTPatAlternative node, Object data);
+
+    Object visit(ASTPatBind node, Object data);
+
+    Object visit(ASTPatExtract node, Object data);
+
+    Object visit(ASTPatExtractInfix node, Object data);
+
+    Object visit(ASTPatInterpolate node, Object data);
+
+    Object visit(ASTPatSeqWildcard node, Object data);
+
+    Object visit(ASTPatTuple node, Object data);
+
+    Object visit(ASTPatTyped node, Object data);
+
+    Object visit(ASTPatVar node, Object data);
+
+    Object visit(ASTPatWildcard node, Object data);
+
+    Object visit(ASTPatXml node, Object data);
+
+    Object visit(ASTPkg node, Object data);
+
+    Object visit(ASTPkgObject node, Object data);
+
+    Object visit(ASTQuasi node, Object data);
+
+    Object visit(ASTSelf node, Object data);
+
+    Object visit(ASTTemplate node, Object data);
+
+    Object visit(ASTTermAnnotate node, Object data);
+
+    Object visit(ASTTermApply node, Object data);
+
+    Object visit(ASTTermApplyInfix node, Object data);
+
+    Object visit(ASTTermApplyType node, Object data);
+
+    Object visit(ASTTermApplyUnary node, Object data);
+
+    Object visit(ASTTermAscribe node, Object data);
+
+    Object visit(ASTTermAssign node, Object data);
+
+    Object visit(ASTTermBlock node, Object data);
+
+    Object visit(ASTTermDo node, Object data);
+
+    Object visit(ASTTermEta node, Object data);
+
+    Object visit(ASTTermFor node, Object data);
+
+    Object visit(ASTTermForYield node, Object data);
+
+    Object visit(ASTTermFunction node, Object data);
+
+    Object visit(ASTTermIf node, Object data);
+
+    Object visit(ASTTermInterpolate node, Object data);
+
+    Object visit(ASTTermMatch node, Object data);
+
+    Object visit(ASTTermName node, Object data);
+
+    Object visit(ASTTermNewAnonymous node, Object data);
+
+    Object visit(ASTTermNew node, Object data);
+
+    Object visit(ASTTermParam node, Object data);
+
+    Object visit(ASTTermPartialFunction node, Object data);
+
+    Object visit(ASTTermPlaceholder node, Object data);
+
+    Object visit(ASTTermRepeated node, Object data);
+
+    Object visit(ASTTermReturn node, Object data);
+
+    Object visit(ASTTermSelect node, Object data);
+
+    Object visit(ASTTermSuper node, Object data);
+
+    Object visit(ASTTermThis node, Object data);
+
+    Object visit(ASTTermThrow node, Object data);
+
+    Object visit(ASTTermTry node, Object data);
+
+    Object visit(ASTTermTryWithHandler node, Object data);
+
+    Object visit(ASTTermTuple node, Object data);
+
+    Object visit(ASTTermWhile node, Object data);
+
+    Object visit(ASTTermXml node, Object data);
+
+    Object visit(ASTTypeAnd node, Object data);
+
+    Object visit(ASTTypeAnnotate node, Object data);
+
+    Object visit(ASTTypeApply node, Object data);
+
+    Object visit(ASTTypeApplyInfix node, Object data);
+
+    Object visit(ASTTypeBounds node, Object data);
+
+    Object visit(ASTTypeByName node, Object data);
+
+    Object visit(ASTTypeExistential node, Object data);
+
+    Object visit(ASTTypeFunction node, Object data);
+
+    Object visit(ASTTypeImplicitFunction node, Object data);
+
+    Object visit(ASTTypeLambda node, Object data);
+
+    Object visit(ASTTypeMethod node, Object data);
+
+    Object visit(ASTTypeName node, Object data);
+
+    Object visit(ASTTypeOr node, Object data);
+
+    Object visit(ASTTypeParam node, Object data);
+
+    Object visit(ASTTypePlaceholder node, Object data);
+
+    Object visit(ASTTypeProject node, Object data);
+
+    Object visit(ASTTypeRefine node, Object data);
+
+    Object visit(ASTTypeRepeated node, Object data);
+
+    Object visit(ASTTypeSelect node, Object data);
+
+    Object visit(ASTTypeSingleton node, Object data);
+
+    Object visit(ASTTypeTuple node, Object data);
+
+    Object visit(ASTTypeVar node, Object data);
+
+    Object visit(ASTTypeWith node, Object data);
+
 }
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/ScalaParserVisitorAdapter.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/ScalaParserVisitorAdapter.java
index cb89a3ad93..f50fc6990c 100644
--- a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/ScalaParserVisitorAdapter.java
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/ScalaParserVisitorAdapter.java
@@ -4,17 +4,798 @@
 
 package net.sourceforge.pmd.lang.scala.ast;
 
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTCase;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTCtorPrimary;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTCtorSecondary;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDeclDef;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDeclType;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDeclVal;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDeclVar;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDefnClass;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDefnDef;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDefnMacro;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDefnObject;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDefnTrait;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDefnType;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDefnVal;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDefnVar;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTEnumeratorGenerator;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTEnumeratorGuard;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTEnumeratorVal;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTImport;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTImporteeName;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTImporteeRename;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTImporteeUnimport;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTImporteeWildcard;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTImporter;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTInit;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitBoolean;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitByte;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitChar;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitDouble;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitFloat;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitInt;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitLong;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitNull;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitShort;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitString;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitSymbol;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitUnit;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModAbstract;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModAnnot;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModCase;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModContravariant;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModCovariant;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModFinal;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModImplicit;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModInline;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModLazy;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModOverride;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModPrivate;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModProtected;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModSealed;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModValParam;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModVarParam;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTNameAnonymous;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTNameIndeterminate;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatAlternative;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatBind;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatExtract;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatExtractInfix;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatInterpolate;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatSeqWildcard;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatTuple;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatTyped;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatVar;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatWildcard;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatXml;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPkg;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPkgObject;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTQuasi;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTSelf;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTSource;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTemplate;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermAnnotate;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermApply;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermApplyInfix;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermApplyType;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermApplyUnary;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermAscribe;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermAssign;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermBlock;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermDo;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermEta;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermFor;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermForYield;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermFunction;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermIf;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermInterpolate;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermMatch;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermName;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermNew;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermNewAnonymous;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermParam;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermPartialFunction;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermPlaceholder;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermRepeated;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermReturn;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermSelect;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermSuper;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermThis;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermThrow;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermTry;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermTryWithHandler;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermTuple;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermWhile;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermXml;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeAnd;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeAnnotate;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeApply;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeApplyInfix;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeBounds;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeByName;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeExistential;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeFunction;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeImplicitFunction;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeLambda;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeMethod;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeName;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeOr;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeParam;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypePlaceholder;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeProject;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeRefine;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeRepeated;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeSelect;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeSingleton;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeTuple;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeVar;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeWith;
+
+import scala.meta.Case;
+import scala.meta.Ctor;
+import scala.meta.Decl;
+import scala.meta.Defn;
+import scala.meta.Enumerator;
+import scala.meta.Import;
+import scala.meta.Importee;
+import scala.meta.Importer;
+import scala.meta.Init;
+import scala.meta.Lit;
+import scala.meta.Mod;
+import scala.meta.Name;
+import scala.meta.Pat;
+import scala.meta.Pkg;
+import scala.meta.Self;
+import scala.meta.Source;
+import scala.meta.Template;
+import scala.meta.Term;
+import scala.meta.Tree.Quasi;
+import scala.meta.Type;
+
 /**
  * An Adapter for the Scala Parser that implements the Visitor Pattern.
  */
 public class ScalaParserVisitorAdapter implements ScalaParserVisitor {
+
     @Override
-    public Object visit(ScalaNode node, Object data) {
+    public Object visit(ScalaNode<?> node, Object data) {
         return node.childrenAccept(this, data);
     }
 
     @Override
-    public Object visit(ASTSourceNode node, Object data) {
-        return visit((ScalaNode) node, data);
+    public Object visit(ASTSource node, Object data) {
+        return visit((ScalaNode<Source>) node, data);
     }
+
+    @Override
+    public Object visit(ASTCase node, Object data) {
+        return visit((ScalaNode<Case>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTCtorPrimary node, Object data) {
+        return visit((ScalaNode<Ctor.Primary>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTCtorSecondary node, Object data) {
+        return visit((ScalaNode<Ctor.Secondary>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTDeclDef node, Object data) {
+        return visit((ScalaNode<Decl.Def>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTDeclType node, Object data) {
+        return visit((ScalaNode<Decl.Type>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTDeclVal node, Object data) {
+        return visit((ScalaNode<Decl.Val>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTDeclVar node, Object data) {
+        return visit((ScalaNode<Decl.Var>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTDefnClass node, Object data) {
+        return visit((ScalaNode<Defn.Class>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTDefnDef node, Object data) {
+        return visit((ScalaNode<Defn.Def>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTDefnMacro node, Object data) {
+        return visit((ScalaNode<Defn.Macro>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTDefnObject node, Object data) {
+        return visit((ScalaNode<Defn.Object>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTDefnTrait node, Object data) {
+        return visit((ScalaNode<Defn.Trait>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTDefnType node, Object data) {
+        return visit((ScalaNode<Defn.Type>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTDefnVal node, Object data) {
+        return visit((ScalaNode<Defn.Val>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTDefnVar node, Object data) {
+        return visit((ScalaNode<Defn.Var>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTEnumeratorGenerator node, Object data) {
+        return visit((ScalaNode<Enumerator.Generator>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTEnumeratorGuard node, Object data) {
+        return visit((ScalaNode<Enumerator.Guard>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTEnumeratorVal node, Object data) {
+        return visit((ScalaNode<Enumerator.Val>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTImport node, Object data) {
+        return visit((ScalaNode<Import>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTImporteeName node, Object data) {
+        return visit((ScalaNode<Importee.Name>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTImporteeRename node, Object data) {
+        return visit((ScalaNode<Importee.Rename>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTImporteeUnimport node, Object data) {
+        return visit((ScalaNode<Importee.Unimport>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTImporteeWildcard node, Object data) {
+        return visit((ScalaNode<Importee.Wildcard>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTImporter node, Object data) {
+        return visit((ScalaNode<Importer>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTInit node, Object data) {
+        return visit((ScalaNode<Init>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTLitBoolean node, Object data) {
+        return visit((ScalaNode<Lit.Boolean>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTLitByte node, Object data) {
+        return visit((ScalaNode<Lit.Byte>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTLitChar node, Object data) {
+        return visit((ScalaNode<Lit.Char>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTLitDouble node, Object data) {
+        return visit((ScalaNode<Lit.Double>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTLitFloat node, Object data) {
+        return visit((ScalaNode<Lit.Float>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTLitInt node, Object data) {
+        return visit((ScalaNode<Lit.Int>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTLitLong node, Object data) {
+        return visit((ScalaNode<Lit.Long>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTLitNull node, Object data) {
+        return visit((ScalaNode<Lit.Null>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTLitShort node, Object data) {
+        return visit((ScalaNode<Lit.Short>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTLitString node, Object data) {
+        return visit((ScalaNode<Lit.String>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTLitSymbol node, Object data) {
+        return visit((ScalaNode<Lit.Symbol>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTLitUnit node, Object data) {
+        return visit((ScalaNode<Lit.Unit>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTModAbstract node, Object data) {
+        return visit((ScalaNode<Mod.Abstract>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTModAnnot node, Object data) {
+        return visit((ScalaNode<Mod.Annot>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTModCase node, Object data) {
+        return visit((ScalaNode<Mod.Case>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTModContravariant node, Object data) {
+        return visit((ScalaNode<Mod.Contravariant>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTModCovariant node, Object data) {
+        return visit((ScalaNode<Mod.Covariant>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTModFinal node, Object data) {
+        return visit((ScalaNode<Mod.Final>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTModImplicit node, Object data) {
+        return visit((ScalaNode<Mod.Implicit>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTModInline node, Object data) {
+        return visit((ScalaNode<Mod.Inline>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTModLazy node, Object data) {
+        return visit((ScalaNode<Mod.Lazy>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTModOverride node, Object data) {
+        return visit((ScalaNode<Mod.Override>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTModPrivate node, Object data) {
+        return visit((ScalaNode<Mod.Private>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTModProtected node, Object data) {
+        return visit((ScalaNode<Mod.Protected>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTModSealed node, Object data) {
+        return visit((ScalaNode<Mod.Sealed>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTModValParam node, Object data) {
+        return visit((ScalaNode<Mod.ValParam>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTModVarParam node, Object data) {
+        return visit((ScalaNode<Mod.VarParam>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTNameAnonymous node, Object data) {
+        return visit((ScalaNode<Name.Anonymous>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTNameIndeterminate node, Object data) {
+        return visit((ScalaNode<Name.Indeterminate>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTPatAlternative node, Object data) {
+        return visit((ScalaNode<Pat.Alternative>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTPatBind node, Object data) {
+        return visit((ScalaNode<Pat.Bind>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTPatExtract node, Object data) {
+        return visit((ScalaNode<Pat.Extract>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTPatExtractInfix node, Object data) {
+        return visit((ScalaNode<Pat.ExtractInfix>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTPatInterpolate node, Object data) {
+        return visit((ScalaNode<Pat.Interpolate>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTPatSeqWildcard node, Object data) {
+        return visit((ScalaNode<Pat.SeqWildcard>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTPatTuple node, Object data) {
+        return visit((ScalaNode<Pat.Tuple>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTPatTyped node, Object data) {
+        return visit((ScalaNode<Pat.Typed>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTPatVar node, Object data) {
+        return visit((ScalaNode<Pat.Var>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTPatWildcard node, Object data) {
+        return visit((ScalaNode<Pat.Wildcard>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTPatXml node, Object data) {
+        return visit((ScalaNode<Pat.Xml>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTPkg node, Object data) {
+        return visit((ScalaNode<Pkg>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTPkgObject node, Object data) {
+        return visit((ScalaNode<Pkg.Object>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTQuasi node, Object data) {
+        return visit((ScalaNode<Quasi>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTSelf node, Object data) {
+        return visit((ScalaNode<Self>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTemplate node, Object data) {
+        return visit((ScalaNode<Template>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermAnnotate node, Object data) {
+        return visit((ScalaNode<Term.Annotate>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermApply node, Object data) {
+        return visit((ScalaNode<Term.Apply>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermApplyInfix node, Object data) {
+        return visit((ScalaNode<Term.ApplyInfix>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermApplyType node, Object data) {
+        return visit((ScalaNode<Term.ApplyType>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermApplyUnary node, Object data) {
+        return visit((ScalaNode<Term.ApplyUnary>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermAscribe node, Object data) {
+        return visit((ScalaNode<Term.Ascribe>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermAssign node, Object data) {
+        return visit((ScalaNode<Term.Assign>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermBlock node, Object data) {
+        return visit((ScalaNode<Term.Block>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermDo node, Object data) {
+        return visit((ScalaNode<Term.Do>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermEta node, Object data) {
+        return visit((ScalaNode<Term.Eta>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermFor node, Object data) {
+        return visit((ScalaNode<Term.For>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermForYield node, Object data) {
+        return visit((ScalaNode<Term.ForYield>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermFunction node, Object data) {
+        return visit((ScalaNode<Term.Function>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermIf node, Object data) {
+        return visit((ScalaNode<Term.If>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermInterpolate node, Object data) {
+        return visit((ScalaNode<Term.Interpolate>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermMatch node, Object data) {
+        return visit((ScalaNode<Term.Match>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermName node, Object data) {
+        return visit((ScalaNode<Term.Name>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermNewAnonymous node, Object data) {
+        return visit((ScalaNode<Term.NewAnonymous>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermNew node, Object data) {
+        return visit((ScalaNode<Term.New>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermParam node, Object data) {
+        return visit((ScalaNode<Term.Param>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermPartialFunction node, Object data) {
+        return visit((ScalaNode<Term.PartialFunction>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermPlaceholder node, Object data) {
+        return visit((ScalaNode<Term.Placeholder>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermRepeated node, Object data) {
+        return visit((ScalaNode<Term.Repeated>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermReturn node, Object data) {
+        return visit((ScalaNode<Term.Return>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermSelect node, Object data) {
+        return visit((ScalaNode<Term.Select>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermSuper node, Object data) {
+        return visit((ScalaNode<Term.Super>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermThis node, Object data) {
+        return visit((ScalaNode<Term.This>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermThrow node, Object data) {
+        return visit((ScalaNode<Term.Throw>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermTry node, Object data) {
+        return visit((ScalaNode<Term.Try>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermTryWithHandler node, Object data) {
+        return visit((ScalaNode<Term.TryWithHandler>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermTuple node, Object data) {
+        return visit((ScalaNode<Term.Tuple>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermWhile node, Object data) {
+        return visit((ScalaNode<Term.While>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermXml node, Object data) {
+        return visit((ScalaNode<Term.Xml>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeAnd node, Object data) {
+        return visit((ScalaNode<Type.And>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeAnnotate node, Object data) {
+        return visit((ScalaNode<Type.Annotate>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeApply node, Object data) {
+        return visit((ScalaNode<Type.Apply>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeApplyInfix node, Object data) {
+        return visit((ScalaNode<Type.ApplyInfix>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeBounds node, Object data) {
+        return visit((ScalaNode<Type.Bounds>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeByName node, Object data) {
+        return visit((ScalaNode<Type.ByName>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeExistential node, Object data) {
+        return visit((ScalaNode<Type.Existential>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeFunction node, Object data) {
+        return visit((ScalaNode<Type.Function>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeImplicitFunction node, Object data) {
+        return visit((ScalaNode<Type.ImplicitFunction>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeLambda node, Object data) {
+        return visit((ScalaNode<Type.Lambda>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeMethod node, Object data) {
+        return visit((ScalaNode<Type.Method>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeName node, Object data) {
+        return visit((ScalaNode<Type.Name>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeOr node, Object data) {
+        return visit((ScalaNode<Type.Or>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeParam node, Object data) {
+        return visit((ScalaNode<Type.Param>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypePlaceholder node, Object data) {
+        return visit((ScalaNode<Type.Placeholder>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeProject node, Object data) {
+        return visit((ScalaNode<Type.Project>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeRefine node, Object data) {
+        return visit((ScalaNode<Type.Refine>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeRepeated node, Object data) {
+        return visit((ScalaNode<Type.Repeated>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeSelect node, Object data) {
+        return visit((ScalaNode<Type.Select>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeSingleton node, Object data) {
+        return visit((ScalaNode<Type.Singleton>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeTuple node, Object data) {
+        return visit((ScalaNode<Type.Tuple>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeVar node, Object data) {
+        return visit((ScalaNode<Type.Var>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeWith node, Object data) {
+        return visit((ScalaNode<Type.With>) node, data);
+    }
+
 }
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/ScalaTreeBuilder.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/ScalaTreeBuilder.java
new file mode 100644
index 0000000000..7b79001166
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/ScalaTreeBuilder.java
@@ -0,0 +1,385 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Stack;
+
+import net.sourceforge.pmd.lang.ast.Node;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTCase;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTCtorPrimary;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTCtorSecondary;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDeclDef;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDeclType;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDeclVal;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDeclVar;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDefnClass;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDefnDef;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDefnMacro;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDefnObject;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDefnTrait;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDefnType;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDefnVal;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDefnVar;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTEnumeratorGenerator;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTEnumeratorGuard;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTEnumeratorVal;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTImport;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTImporteeName;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTImporteeRename;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTImporteeUnimport;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTImporteeWildcard;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTImporter;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTInit;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitBoolean;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitByte;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitChar;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitDouble;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitFloat;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitInt;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitLong;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitNull;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitShort;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitString;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitSymbol;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitUnit;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModAbstract;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModAnnot;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModCase;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModContravariant;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModCovariant;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModFinal;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModImplicit;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModInline;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModLazy;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModOverride;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModPrivate;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModProtected;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModSealed;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModValParam;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModVarParam;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTNameAnonymous;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTNameIndeterminate;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatAlternative;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatBind;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatExtract;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatExtractInfix;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatInterpolate;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatSeqWildcard;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatTuple;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatTyped;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatVar;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatWildcard;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatXml;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPkg;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPkgObject;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTQuasi;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTSelf;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTSource;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTemplate;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermAnnotate;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermApply;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermApplyInfix;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermApplyType;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermApplyUnary;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermAscribe;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermAssign;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermBlock;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermDo;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermEta;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermFor;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermForYield;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermFunction;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermIf;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermInterpolate;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermMatch;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermName;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermNew;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermNewAnonymous;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermParam;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermPartialFunction;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermPlaceholder;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermRepeated;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermReturn;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermSelect;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermSuper;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermThis;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermThrow;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermTry;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermTryWithHandler;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermTuple;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermWhile;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermXml;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeAnd;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeAnnotate;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeApply;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeApplyInfix;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeBounds;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeByName;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeExistential;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeFunction;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeImplicitFunction;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeLambda;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeMethod;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeName;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeOr;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeParam;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypePlaceholder;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeProject;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeRefine;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeRepeated;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeSelect;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeSingleton;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeTuple;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeVar;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeWith;
+import net.sourceforge.pmd.lang.scala.ast.nodes.AbstractScalaNode;
+
+import scala.meta.Case;
+import scala.meta.Ctor;
+import scala.meta.Decl;
+import scala.meta.Defn;
+import scala.meta.Enumerator;
+import scala.meta.Import;
+import scala.meta.Importee;
+import scala.meta.Importer;
+import scala.meta.Init;
+import scala.meta.Lit;
+import scala.meta.Mod;
+import scala.meta.Name;
+import scala.meta.Pat;
+import scala.meta.Pkg;
+import scala.meta.Self;
+import scala.meta.Source;
+import scala.meta.Template;
+import scala.meta.Term;
+import scala.meta.Tree;
+import scala.meta.Tree.Quasi;
+import scala.meta.Type;
+
+/**
+ * Translates Scala's AST to a PMD-compatible AST.
+ *
+ */
+public class ScalaTreeBuilder {
+
+    private static final Map<Class<? extends Tree>, Constructor<? extends AbstractScalaNode<?>>> NODE_TYPE_TO_NODE_ADAPTER_TYPE = new HashMap<>();
+
+    static {
+        register(Case.class, ASTCase.class);
+        register(Ctor.Primary.class, ASTCtorPrimary.class);
+        register(Ctor.Secondary.class, ASTCtorSecondary.class);
+        register(Decl.Def.class, ASTDeclDef.class);
+        register(Decl.Type.class, ASTDeclType.class);
+        register(Decl.Val.class, ASTDeclVal.class);
+        register(Decl.Var.class, ASTDeclVar.class);
+        register(Defn.Class.class, ASTDefnClass.class);
+        register(Defn.Def.class, ASTDefnDef.class);
+        register(Defn.Macro.class, ASTDefnMacro.class);
+        register(Defn.Object.class, ASTDefnObject.class);
+        register(Defn.Trait.class, ASTDefnTrait.class);
+        register(Defn.Type.class, ASTDefnType.class);
+        register(Defn.Val.class, ASTDefnVal.class);
+        register(Defn.Var.class, ASTDefnVar.class);
+        register(Enumerator.Generator.class, ASTEnumeratorGenerator.class);
+        register(Enumerator.Guard.class, ASTEnumeratorGuard.class);
+        register(Enumerator.Val.class, ASTEnumeratorVal.class);
+        register(Import.class, ASTImport.class);
+        register(Importee.Name.class, ASTImporteeName.class);
+        register(Importee.Rename.class, ASTImporteeRename.class);
+        register(Importee.Unimport.class, ASTImporteeUnimport.class);
+        register(Importee.Wildcard.class, ASTImporteeWildcard.class);
+        register(Importer.class, ASTImporter.class);
+        register(Init.class, ASTInit.class);
+        register(Lit.Boolean.class, ASTLitBoolean.class);
+        register(Lit.Byte.class, ASTLitByte.class);
+        register(Lit.Char.class, ASTLitChar.class);
+        register(Lit.Double.class, ASTLitDouble.class);
+        register(Lit.Float.class, ASTLitFloat.class);
+        register(Lit.Int.class, ASTLitInt.class);
+        register(Lit.Long.class, ASTLitLong.class);
+        register(Lit.Null.class, ASTLitNull.class);
+        register(Lit.Short.class, ASTLitShort.class);
+        register(Lit.String.class, ASTLitString.class);
+        register(Lit.Symbol.class, ASTLitSymbol.class);
+        register(Lit.Unit.class, ASTLitUnit.class);
+        register(Mod.Abstract.class, ASTModAbstract.class);
+        register(Mod.Annot.class, ASTModAnnot.class);
+        register(Mod.Case.class, ASTModCase.class);
+        register(Mod.Contravariant.class, ASTModContravariant.class);
+        register(Mod.Covariant.class, ASTModCovariant.class);
+        register(Mod.Final.class, ASTModFinal.class);
+        register(Mod.Implicit.class, ASTModImplicit.class);
+        register(Mod.Inline.class, ASTModInline.class);
+        register(Mod.Lazy.class, ASTModLazy.class);
+        register(Mod.Override.class, ASTModOverride.class);
+        register(Mod.Private.class, ASTModPrivate.class);
+        register(Mod.Protected.class, ASTModProtected.class);
+        register(Mod.Sealed.class, ASTModSealed.class);
+        register(Mod.ValParam.class, ASTModValParam.class);
+        register(Mod.VarParam.class, ASTModVarParam.class);
+        register(Name.Anonymous.class, ASTNameAnonymous.class);
+        register(Name.Indeterminate.class, ASTNameIndeterminate.class);
+        register(Pat.Alternative.class, ASTPatAlternative.class);
+        register(Pat.Bind.class, ASTPatBind.class);
+        register(Pat.Extract.class, ASTPatExtract.class);
+        register(Pat.ExtractInfix.class, ASTPatExtractInfix.class);
+        register(Pat.Interpolate.class, ASTPatInterpolate.class);
+        register(Pat.SeqWildcard.class, ASTPatSeqWildcard.class);
+        register(Pat.Tuple.class, ASTPatTuple.class);
+        register(Pat.Typed.class, ASTPatTyped.class);
+        register(Pat.Var.class, ASTPatVar.class);
+        register(Pat.Wildcard.class, ASTPatWildcard.class);
+        register(Pat.Xml.class, ASTPatXml.class);
+        register(Pkg.class, ASTPkg.class);
+        register(Pkg.Object.class, ASTPkgObject.class);
+        register(Quasi.class, ASTQuasi.class);
+        register(Self.class, ASTSelf.class);
+        register(Source.class, ASTSource.class);
+        register(Template.class, ASTTemplate.class);
+        register(Term.Annotate.class, ASTTermAnnotate.class);
+        register(Term.Apply.class, ASTTermApply.class);
+        register(Term.ApplyInfix.class, ASTTermApplyInfix.class);
+        register(Term.ApplyType.class, ASTTermApplyType.class);
+        register(Term.ApplyUnary.class, ASTTermApplyUnary.class);
+        register(Term.Ascribe.class, ASTTermAscribe.class);
+        register(Term.Assign.class, ASTTermAssign.class);
+        register(Term.Block.class, ASTTermBlock.class);
+        register(Term.Do.class, ASTTermDo.class);
+        register(Term.Eta.class, ASTTermEta.class);
+        register(Term.For.class, ASTTermFor.class);
+        register(Term.ForYield.class, ASTTermForYield.class);
+        register(Term.Function.class, ASTTermFunction.class);
+        register(Term.If.class, ASTTermIf.class);
+        register(Term.Interpolate.class, ASTTermInterpolate.class);
+        register(Term.Match.class, ASTTermMatch.class);
+        register(Term.Name.class, ASTTermName.class);
+        register(Term.NewAnonymous.class, ASTTermNewAnonymous.class);
+        register(Term.New.class, ASTTermNew.class);
+        register(Term.Param.class, ASTTermParam.class);
+        register(Term.PartialFunction.class, ASTTermPartialFunction.class);
+        register(Term.Placeholder.class, ASTTermPlaceholder.class);
+        register(Term.Repeated.class, ASTTermRepeated.class);
+        register(Term.Return.class, ASTTermReturn.class);
+        register(Term.Select.class, ASTTermSelect.class);
+        register(Term.Super.class, ASTTermSuper.class);
+        register(Term.This.class, ASTTermThis.class);
+        register(Term.Throw.class, ASTTermThrow.class);
+        register(Term.Try.class, ASTTermTry.class);
+        register(Term.TryWithHandler.class, ASTTermTryWithHandler.class);
+        register(Term.Tuple.class, ASTTermTuple.class);
+        register(Term.While.class, ASTTermWhile.class);
+        register(Term.Xml.class, ASTTermXml.class);
+        register(Type.And.class, ASTTypeAnd.class);
+        register(Type.Annotate.class, ASTTypeAnnotate.class);
+        register(Type.Apply.class, ASTTypeApply.class);
+        register(Type.ApplyInfix.class, ASTTypeApplyInfix.class);
+        register(Type.Bounds.class, ASTTypeBounds.class);
+        register(Type.ByName.class, ASTTypeByName.class);
+        register(Type.Existential.class, ASTTypeExistential.class);
+        register(Type.Function.class, ASTTypeFunction.class);
+        register(Type.ImplicitFunction.class, ASTTypeImplicitFunction.class);
+        register(Type.Lambda.class, ASTTypeLambda.class);
+        register(Type.Method.class, ASTTypeMethod.class);
+        register(Type.Name.class, ASTTypeName.class);
+        register(Type.Or.class, ASTTypeOr.class);
+        register(Type.Param.class, ASTTypeParam.class);
+        register(Type.Placeholder.class, ASTTypePlaceholder.class);
+        register(Type.Project.class, ASTTypeProject.class);
+        register(Type.Refine.class, ASTTypeRefine.class);
+        register(Type.Repeated.class, ASTTypeRepeated.class);
+        register(Type.Select.class, ASTTypeSelect.class);
+        register(Type.Singleton.class, ASTTypeSingleton.class);
+        register(Type.Tuple.class, ASTTypeTuple.class);
+        register(Type.Var.class, ASTTypeVar.class);
+        register(Type.With.class, ASTTypeWith.class);
+    }
+
+    // The nodes having children built.
+    private Stack<Node> nodes = new Stack<>();
+
+    // The Scala nodes with children to build.
+    private Stack<Tree> parents = new Stack<>();
+
+    private static <T extends Tree> void register(Class<T> nodeType,
+            Class<? extends AbstractScalaNode<T>> nodeAdapterType) {
+        try {
+            NODE_TYPE_TO_NODE_ADAPTER_TYPE.put(nodeType, nodeAdapterType.getConstructor(nodeType));
+        } catch (SecurityException | NoSuchMethodException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    static <T extends Tree> AbstractScalaNode<T> createNodeAdapter(T node) {
+        try {
+
+            Constructor<? extends AbstractScalaNode<T>> constructor = null;
+
+            // This isInstance is unfortunately necessary as Scala gives us
+            // access to the Interface (Trait) of classes at compile time, but
+            // at runtime only operates using a synthetic Impl class. So at
+            // runtime, Case.class is really CaseImpl.class due to the
+            // translation between Scala Traits and Java Classes
+            for (Class<?> treeClass : NODE_TYPE_TO_NODE_ADAPTER_TYPE.keySet()) {
+                if (treeClass.isInstance(node)) {
+                    constructor = (Constructor<? extends AbstractScalaNode<T>>) NODE_TYPE_TO_NODE_ADAPTER_TYPE
+                            .get(treeClass);
+                }
+            }
+
+            if (constructor == null) {
+                throw new IllegalArgumentException(
+                        "There is no Node adapter class registered for the Node class: " + node.getClass());
+            }
+            return constructor.newInstance(node);
+            
+        } catch (InstantiationException | IllegalAccessException e) {
+            throw new RuntimeException(e);
+        } catch (InvocationTargetException e) {
+            throw new RuntimeException(e.getTargetException());
+        }
+    }
+
+    /**
+     * Construct a matching tree that implements the PMD Node interface.
+     * 
+     * @param <T>
+     *            the scala node that extends the Tree trait
+     * @param astNode
+     *            the Java node that extends the PMD Node interface
+     * @return a PMD compatible node representing the Scala AST node
+     */
+    public <T extends Tree> AbstractScalaNode<T> build(T astNode) {
+        return buildInternal(astNode);
+    }
+
+    private <T extends Tree> AbstractScalaNode<T> buildInternal(T astNode) {
+        // Create a Node
+        AbstractScalaNode<T> node = createNodeAdapter(astNode);
+
+        // Append to parent
+        Node parent = nodes.isEmpty() ? null : nodes.peek();
+        if (parent != null) {
+            parent.jjtAddChild(node, parent.jjtGetNumChildren());
+            node.jjtSetParent(parent);
+        }
+
+        // Build the children...
+        nodes.push(node);
+        parents.push(astNode);
+        int childrenNum = astNode.children().size();
+        for (int i = 0; i < childrenNum; i++) {
+            buildInternal(astNode.children().apply(i));
+        }
+        nodes.pop();
+        parents.pop();
+
+        return node;
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/ScalaWrapperNode.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/ScalaWrapperNode.java
deleted file mode 100644
index 08ab6e950c..0000000000
--- a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/ScalaWrapperNode.java
+++ /dev/null
@@ -1,155 +0,0 @@
-/**
- * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
- */
-
-package net.sourceforge.pmd.lang.scala.ast;
-
-import java.util.Objects;
-
-import net.sourceforge.pmd.lang.ast.AbstractNode;
-import net.sourceforge.pmd.lang.ast.Node;
-import net.sourceforge.pmd.lang.scala.ScalaParser;
-
-import scala.meta.Tree;
-import scala.meta.inputs.Position;
-
-/**
- * The Java-wrapper for Scala Nodes to allow interoperability with PMD.
- */
-public class ScalaWrapperNode extends AbstractNode implements ScalaNode {
-    private Tree node;
-    private ScalaParser parser;
-
-    /**
-     * Create a new Java Wrapper around a Scala node.
-     * 
-     * @param scalaParser
-     *            the ScalaParser used to generate the node
-     * @param scalaNode
-     *            the scalaNode node to wrap
-     */
-    public ScalaWrapperNode(ScalaParser scalaParser, Tree scalaNode) {
-        super(0);
-        this.parser = scalaParser;
-        this.node = scalaNode;
-        Position pos = node.pos();
-        beginLine = pos.startLine() + 1;
-        endLine = pos.endLine() + 1;
-        beginColumn = pos.startColumn() + 1;
-        endColumn = pos.endColumn() + 1;
-    }
-
-    @Override
-    public Tree getNode() {
-        return node;
-    }
-
-    @Override
-    public Object accept(ScalaParserVisitor visitor, Object data) {
-        return visitor.visit(this, data);
-    }
-
-    @Override
-    public Object childrenAccept(ScalaParserVisitor visitor, Object data) {
-        int numChildren = jjtGetNumChildren();
-        for (int i = 0; i < numChildren; ++i) {
-            jjtGetChild(i).accept(visitor, data);
-        }
-        return data;
-    }
-
-    @Override
-    public String getXPathNodeName() {
-        return node.productPrefix().replace(".", "");
-    }
-
-    @Override
-    public void jjtClose() {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public void jjtSetParent(Node parent) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public ScalaWrapperNode jjtGetParent() {
-        if (node.parent().isEmpty()) {
-            return null;
-        }
-        return parser.wrapNode(node.parent().get());
-    }
-
-    @Override
-    public void jjtAddChild(Node child, int index) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public void jjtSetChildIndex(int index) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public int jjtGetChildIndex() {
-        int idx = node.parent().get().children().indexOf(node);
-        if (idx == -1) {
-            throw new IllegalStateException("This node is not a child of its parent: " + node);
-        }
-        return idx;
-    }
-
-    @Override
-    public ScalaWrapperNode jjtGetChild(int index) {
-        return parser.wrapNode(node.children().apply(index));
-    }
-
-    @Override
-    public int jjtGetNumChildren() {
-        return node.children().size();
-    }
-
-    @Override
-    public int jjtGetId() {
-        return 0;
-    }
-
-    @Override
-    public String getImage() {
-        String image = null;
-        if (node instanceof scala.meta.Lit) {
-            image = String.valueOf(((scala.meta.Lit) node).value());
-        } else if (node instanceof scala.meta.Name) {
-            image = ((scala.meta.Name) node).value().toString();
-        } else if (node instanceof scala.meta.Type.Name) {
-            image = ((scala.meta.Type.Name) node).value();
-        } else if (node instanceof scala.meta.Term.Name) {
-            image = ((scala.meta.Term.Name) node).value();
-        } else if (node instanceof scala.meta.Type.Var.Name) {
-            image = ((scala.meta.Type.Var.Name) node).value();
-        }
-        return image;
-    }
-
-    @Override
-    public void setImage(String image) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public boolean hasImageEqualTo(String image) {
-        return Objects.equals(image, getImage());
-    }
-
-    @Override
-    public void remove() {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public void removeChildAtIndex(int childIndex) {
-        throw new UnsupportedOperationException();
-    }
-
-}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTCase.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTCase.java
new file mode 100644
index 0000000000..68dcf51ce8
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTCase.java
@@ -0,0 +1,15 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Case;
+
+public class ASTCase extends AbstractScalaNode<Case> {
+
+    public ASTCase(Case scalaNode) {
+        super(scalaNode);
+    }
+
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTCtorPrimary.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTCtorPrimary.java
new file mode 100644
index 0000000000..89b9987f1f
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTCtorPrimary.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Ctor;
+
+public class ASTCtorPrimary extends AbstractScalaNode<Ctor.Primary> {
+
+    public ASTCtorPrimary(Ctor.Primary scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTCtorSecondary.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTCtorSecondary.java
new file mode 100644
index 0000000000..b60eb01092
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTCtorSecondary.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Ctor;
+
+public class ASTCtorSecondary extends AbstractScalaNode<Ctor.Secondary> {
+
+    public ASTCtorSecondary(Ctor.Secondary scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDeclDef.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDeclDef.java
new file mode 100644
index 0000000000..1cf9129feb
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDeclDef.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Decl;
+
+public class ASTDeclDef extends AbstractScalaNode<Decl.Def> {
+
+    public ASTDeclDef(Decl.Def scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDeclType.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDeclType.java
new file mode 100644
index 0000000000..d5fd347919
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDeclType.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Decl;
+
+public class ASTDeclType extends AbstractScalaNode<Decl.Type> {
+
+    public ASTDeclType(Decl.Type scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDeclVal.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDeclVal.java
new file mode 100644
index 0000000000..300229a17b
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDeclVal.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Decl;
+
+public class ASTDeclVal extends AbstractScalaNode<Decl.Val> {
+
+    public ASTDeclVal(Decl.Val scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDeclVar.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDeclVar.java
new file mode 100644
index 0000000000..00757746c0
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDeclVar.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Decl;
+
+public class ASTDeclVar extends AbstractScalaNode<Decl.Var> {
+
+    public ASTDeclVar(Decl.Var scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDefnClass.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDefnClass.java
new file mode 100644
index 0000000000..86e9ae1716
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDefnClass.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Defn;
+
+public class ASTDefnClass extends AbstractScalaNode<Defn.Class> {
+
+    public ASTDefnClass(Defn.Class scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDefnDef.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDefnDef.java
new file mode 100644
index 0000000000..ba5fb6224b
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDefnDef.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Defn;
+
+public class ASTDefnDef extends AbstractScalaNode<Defn.Def> {
+
+    public ASTDefnDef(Defn.Def scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDefnMacro.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDefnMacro.java
new file mode 100644
index 0000000000..2e19160f6c
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDefnMacro.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Defn;
+
+public class ASTDefnMacro extends AbstractScalaNode<Defn.Macro> {
+
+    public ASTDefnMacro(Defn.Macro scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDefnObject.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDefnObject.java
new file mode 100644
index 0000000000..a743446dfd
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDefnObject.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Defn;
+
+public class ASTDefnObject extends AbstractScalaNode<Defn.Object> {
+
+    public ASTDefnObject(Defn.Object scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDefnTrait.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDefnTrait.java
new file mode 100644
index 0000000000..5c044a6be4
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDefnTrait.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Defn;
+
+public class ASTDefnTrait extends AbstractScalaNode<Defn.Trait> {
+
+    public ASTDefnTrait(Defn.Trait scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDefnType.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDefnType.java
new file mode 100644
index 0000000000..28af32fb63
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDefnType.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Defn;
+
+public class ASTDefnType extends AbstractScalaNode<Defn.Type> {
+
+    public ASTDefnType(Defn.Type scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDefnVal.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDefnVal.java
new file mode 100644
index 0000000000..0427320bae
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDefnVal.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Defn;
+
+public class ASTDefnVal extends AbstractScalaNode<Defn.Val> {
+
+    public ASTDefnVal(Defn.Val scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDefnVar.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDefnVar.java
new file mode 100644
index 0000000000..23868d2390
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTDefnVar.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Defn;
+
+public class ASTDefnVar extends AbstractScalaNode<Defn.Var> {
+
+    public ASTDefnVar(Defn.Var scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTEnumeratorGenerator.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTEnumeratorGenerator.java
new file mode 100644
index 0000000000..0287aa4f64
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTEnumeratorGenerator.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Enumerator;
+
+public class ASTEnumeratorGenerator extends AbstractScalaNode<Enumerator.Generator> {
+
+    public ASTEnumeratorGenerator(Enumerator.Generator scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTEnumeratorGuard.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTEnumeratorGuard.java
new file mode 100644
index 0000000000..0af5957523
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTEnumeratorGuard.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Enumerator;
+
+public class ASTEnumeratorGuard extends AbstractScalaNode<Enumerator.Guard> {
+
+    public ASTEnumeratorGuard(Enumerator.Guard scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTEnumeratorVal.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTEnumeratorVal.java
new file mode 100644
index 0000000000..d7f6d620be
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTEnumeratorVal.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Enumerator;
+
+public class ASTEnumeratorVal extends AbstractScalaNode<Enumerator.Val> {
+
+    public ASTEnumeratorVal(Enumerator.Val scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTImport.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTImport.java
new file mode 100644
index 0000000000..66967a1d97
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTImport.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Import;
+
+public class ASTImport extends AbstractScalaNode<Import> {
+
+    public ASTImport(Import scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTImporteeName.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTImporteeName.java
new file mode 100644
index 0000000000..15c1a83791
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTImporteeName.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Importee;
+
+public class ASTImporteeName extends AbstractScalaNode<Importee.Name> {
+
+    public ASTImporteeName(Importee.Name scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTImporteeRename.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTImporteeRename.java
new file mode 100644
index 0000000000..052080103e
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTImporteeRename.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Importee;
+
+public class ASTImporteeRename extends AbstractScalaNode<Importee.Rename> {
+
+    public ASTImporteeRename(Importee.Rename scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTImporteeUnimport.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTImporteeUnimport.java
new file mode 100644
index 0000000000..924c8a1c20
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTImporteeUnimport.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Importee;
+
+public class ASTImporteeUnimport extends AbstractScalaNode<Importee.Unimport> {
+
+    public ASTImporteeUnimport(Importee.Unimport scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTImporteeWildcard.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTImporteeWildcard.java
new file mode 100644
index 0000000000..a8136f06eb
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTImporteeWildcard.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Importee;
+
+public class ASTImporteeWildcard extends AbstractScalaNode<Importee.Wildcard> {
+
+    public ASTImporteeWildcard(Importee.Wildcard scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTImporter.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTImporter.java
new file mode 100644
index 0000000000..ee8b0e4ebb
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTImporter.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Importer;
+
+public class ASTImporter extends AbstractScalaNode<Importer> {
+
+    public ASTImporter(Importer scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTInit.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTInit.java
new file mode 100644
index 0000000000..4425ccb064
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTInit.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Init;
+
+public class ASTInit extends AbstractScalaNode<Init> {
+
+    public ASTInit(Init scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitBoolean.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitBoolean.java
new file mode 100644
index 0000000000..7705b19b62
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitBoolean.java
@@ -0,0 +1,19 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Lit;
+
+public class ASTLitBoolean extends AbstractScalaNode<Lit.Boolean> {
+
+    public ASTLitBoolean(Lit.Boolean scalaNode) {
+        super(scalaNode);
+    }
+
+    @Override
+    public String getImage() {
+        return String.valueOf(getNode().value());
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitByte.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitByte.java
new file mode 100644
index 0000000000..f25172e218
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitByte.java
@@ -0,0 +1,19 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Lit;
+
+public class ASTLitByte extends AbstractScalaNode<Lit.Byte> {
+
+    public ASTLitByte(Lit.Byte scalaNode) {
+        super(scalaNode);
+    }
+
+    @Override
+    public String getImage() {
+        return String.valueOf(getNode().value());
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitChar.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitChar.java
new file mode 100644
index 0000000000..1117ffdb1f
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitChar.java
@@ -0,0 +1,19 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Lit;
+
+public class ASTLitChar extends AbstractScalaNode<Lit.Char> {
+
+    public ASTLitChar(Lit.Char scalaNode) {
+        super(scalaNode);
+    }
+
+    @Override
+    public String getImage() {
+        return String.valueOf(getNode().value());
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitDouble.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitDouble.java
new file mode 100644
index 0000000000..8c7d8ad289
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitDouble.java
@@ -0,0 +1,19 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Lit;
+
+public class ASTLitDouble extends AbstractScalaNode<Lit.Double> {
+
+    public ASTLitDouble(Lit.Double scalaNode) {
+        super(scalaNode);
+    }
+
+    @Override
+    public String getImage() {
+        return String.valueOf(getNode().value());
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitFloat.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitFloat.java
new file mode 100644
index 0000000000..7708ea6edd
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitFloat.java
@@ -0,0 +1,19 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Lit;
+
+public class ASTLitFloat extends AbstractScalaNode<Lit.Float> {
+
+    public ASTLitFloat(Lit.Float scalaNode) {
+        super(scalaNode);
+    }
+
+    @Override
+    public String getImage() {
+        return String.valueOf(getNode().value());
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitInt.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitInt.java
new file mode 100644
index 0000000000..c2d40f9e4a
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitInt.java
@@ -0,0 +1,19 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Lit;
+
+public class ASTLitInt extends AbstractScalaNode<Lit.Int> {
+
+    public ASTLitInt(Lit.Int scalaNode) {
+        super(scalaNode);
+    }
+
+    @Override
+    public String getImage() {
+        return String.valueOf(getNode().value());
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitLong.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitLong.java
new file mode 100644
index 0000000000..6ecb1aae7c
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitLong.java
@@ -0,0 +1,19 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Lit;
+
+public class ASTLitLong extends AbstractScalaNode<Lit.Long> {
+
+    public ASTLitLong(Lit.Long scalaNode) {
+        super(scalaNode);
+    }
+
+    @Override
+    public String getImage() {
+        return String.valueOf(getNode().value());
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitNull.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitNull.java
new file mode 100644
index 0000000000..82bce9febf
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitNull.java
@@ -0,0 +1,19 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Lit;
+
+public class ASTLitNull extends AbstractScalaNode<Lit.Null> {
+
+    public ASTLitNull(Lit.Null scalaNode) {
+        super(scalaNode);
+    }
+
+    @Override
+    public String getImage() {
+        return String.valueOf(getNode().value());
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitShort.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitShort.java
new file mode 100644
index 0000000000..f35456f62a
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitShort.java
@@ -0,0 +1,19 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Lit;
+
+public class ASTLitShort extends AbstractScalaNode<Lit.Short> {
+
+    public ASTLitShort(Lit.Short scalaNode) {
+        super(scalaNode);
+    }
+
+    @Override
+    public String getImage() {
+        return String.valueOf(getNode().value());
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitString.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitString.java
new file mode 100644
index 0000000000..55650b459a
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitString.java
@@ -0,0 +1,19 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Lit;
+
+public class ASTLitString extends AbstractScalaNode<Lit.String> {
+
+    public ASTLitString(Lit.String scalaNode) {
+        super(scalaNode);
+    }
+
+    @Override
+    public String getImage() {
+        return String.valueOf(getNode().value());
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitSymbol.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitSymbol.java
new file mode 100644
index 0000000000..562effb9fc
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitSymbol.java
@@ -0,0 +1,19 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Lit;
+
+public class ASTLitSymbol extends AbstractScalaNode<Lit.Symbol> {
+
+    public ASTLitSymbol(Lit.Symbol scalaNode) {
+        super(scalaNode);
+    }
+
+    @Override
+    public String getImage() {
+        return String.valueOf(getNode().value());
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitUnit.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitUnit.java
new file mode 100644
index 0000000000..8a9f02d06d
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTLitUnit.java
@@ -0,0 +1,19 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Lit;
+
+public class ASTLitUnit extends AbstractScalaNode<Lit.Unit> {
+
+    public ASTLitUnit(Lit.Unit scalaNode) {
+        super(scalaNode);
+    }
+
+    @Override
+    public String getImage() {
+        return String.valueOf(getNode().value());
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModAbstract.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModAbstract.java
new file mode 100644
index 0000000000..5803813887
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModAbstract.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Mod;
+
+public class ASTModAbstract extends AbstractScalaNode<Mod.Abstract> {
+
+    public ASTModAbstract(Mod.Abstract scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModAnnot.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModAnnot.java
new file mode 100644
index 0000000000..aef0c0ea63
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModAnnot.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Mod;
+
+public class ASTModAnnot extends AbstractScalaNode<Mod.Annot> {
+
+    public ASTModAnnot(Mod.Annot scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModCase.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModCase.java
new file mode 100644
index 0000000000..99bb0807f0
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModCase.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Mod;
+
+public class ASTModCase extends AbstractScalaNode<Mod.Case> {
+
+    public ASTModCase(Mod.Case scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModContravariant.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModContravariant.java
new file mode 100644
index 0000000000..b0a7ab2c16
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModContravariant.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Mod;
+
+public class ASTModContravariant extends AbstractScalaNode<Mod.Contravariant> {
+
+    public ASTModContravariant(Mod.Contravariant scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModCovariant.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModCovariant.java
new file mode 100644
index 0000000000..0830d370b9
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModCovariant.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Mod;
+
+public class ASTModCovariant extends AbstractScalaNode<Mod.Covariant> {
+
+    public ASTModCovariant(Mod.Covariant scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModFinal.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModFinal.java
new file mode 100644
index 0000000000..6e86166813
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModFinal.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Mod;
+
+public class ASTModFinal extends AbstractScalaNode<Mod.Final> {
+
+    public ASTModFinal(Mod.Final scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModImplicit.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModImplicit.java
new file mode 100644
index 0000000000..3791f5d419
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModImplicit.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Mod;
+
+public class ASTModImplicit extends AbstractScalaNode<Mod.Implicit> {
+
+    public ASTModImplicit(Mod.Implicit scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModInline.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModInline.java
new file mode 100644
index 0000000000..0fa7c9e054
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModInline.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Mod;
+
+public class ASTModInline extends AbstractScalaNode<Mod.Inline> {
+
+    public ASTModInline(Mod.Inline scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModLazy.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModLazy.java
new file mode 100644
index 0000000000..3df1c3d0aa
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModLazy.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Mod;
+
+public class ASTModLazy extends AbstractScalaNode<Mod.Lazy> {
+
+    public ASTModLazy(Mod.Lazy scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModOverride.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModOverride.java
new file mode 100644
index 0000000000..96c3229e88
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModOverride.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Mod;
+
+public class ASTModOverride extends AbstractScalaNode<Mod.Override> {
+
+    public ASTModOverride(Mod.Override scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModPrivate.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModPrivate.java
new file mode 100644
index 0000000000..21032cf3ea
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModPrivate.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Mod;
+
+public class ASTModPrivate extends AbstractScalaNode<Mod.Private> {
+
+    public ASTModPrivate(Mod.Private scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModProtected.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModProtected.java
new file mode 100644
index 0000000000..e9ed2f5d6f
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModProtected.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Mod;
+
+public class ASTModProtected extends AbstractScalaNode<Mod.Protected> {
+
+    public ASTModProtected(Mod.Protected scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModSealed.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModSealed.java
new file mode 100644
index 0000000000..c039079071
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModSealed.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Mod;
+
+public class ASTModSealed extends AbstractScalaNode<Mod.Sealed> {
+
+    public ASTModSealed(Mod.Sealed scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModValParam.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModValParam.java
new file mode 100644
index 0000000000..d03a0f682c
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModValParam.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Mod;
+
+public class ASTModValParam extends AbstractScalaNode<Mod.ValParam> {
+
+    public ASTModValParam(Mod.ValParam scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModVarParam.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModVarParam.java
new file mode 100644
index 0000000000..cdfd453c74
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTModVarParam.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Mod;
+
+public class ASTModVarParam extends AbstractScalaNode<Mod.VarParam> {
+
+    public ASTModVarParam(Mod.VarParam scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTNameAnonymous.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTNameAnonymous.java
new file mode 100644
index 0000000000..2a1969d08c
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTNameAnonymous.java
@@ -0,0 +1,19 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Name;
+
+public class ASTNameAnonymous extends AbstractScalaNode<Name.Anonymous> {
+
+    public ASTNameAnonymous(Name.Anonymous scalaNode) {
+        super(scalaNode);
+    }
+
+    @Override
+    public String getImage() {
+        return getNode().value();
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTNameIndeterminate.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTNameIndeterminate.java
new file mode 100644
index 0000000000..14eeeca7b1
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTNameIndeterminate.java
@@ -0,0 +1,19 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Name;
+
+public class ASTNameIndeterminate extends AbstractScalaNode<Name.Indeterminate> {
+
+    public ASTNameIndeterminate(Name.Indeterminate scalaNode) {
+        super(scalaNode);
+    }
+
+    @Override
+    public String getImage() {
+        return getNode().value();
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatAlternative.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatAlternative.java
new file mode 100644
index 0000000000..7918552987
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatAlternative.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Pat;
+
+public class ASTPatAlternative extends AbstractScalaNode<Pat.Alternative> {
+
+    public ASTPatAlternative(Pat.Alternative scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatBind.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatBind.java
new file mode 100644
index 0000000000..d286d4f861
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatBind.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Pat;
+
+public class ASTPatBind extends AbstractScalaNode<Pat.Bind> {
+
+    public ASTPatBind(Pat.Bind scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatExtract.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatExtract.java
new file mode 100644
index 0000000000..5e1ee8b216
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatExtract.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Pat;
+
+public class ASTPatExtract extends AbstractScalaNode<Pat.Extract> {
+
+    public ASTPatExtract(Pat.Extract scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatExtractInfix.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatExtractInfix.java
new file mode 100644
index 0000000000..f365dfef45
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatExtractInfix.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Pat;
+
+public class ASTPatExtractInfix extends AbstractScalaNode<Pat.ExtractInfix> {
+
+    public ASTPatExtractInfix(Pat.ExtractInfix scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatInterpolate.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatInterpolate.java
new file mode 100644
index 0000000000..9acab72418
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatInterpolate.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Pat;
+
+public class ASTPatInterpolate extends AbstractScalaNode<Pat.Interpolate> {
+
+    public ASTPatInterpolate(Pat.Interpolate scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatSeqWildcard.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatSeqWildcard.java
new file mode 100644
index 0000000000..977599fb7f
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatSeqWildcard.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Pat;
+
+public class ASTPatSeqWildcard extends AbstractScalaNode<Pat.SeqWildcard> {
+
+    public ASTPatSeqWildcard(Pat.SeqWildcard scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatTuple.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatTuple.java
new file mode 100644
index 0000000000..3866f189ae
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatTuple.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Pat;
+
+public class ASTPatTuple extends AbstractScalaNode<Pat.Tuple> {
+
+    public ASTPatTuple(Pat.Tuple scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatTyped.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatTyped.java
new file mode 100644
index 0000000000..51f196e56d
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatTyped.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Pat;
+
+public class ASTPatTyped extends AbstractScalaNode<Pat.Typed> {
+
+    public ASTPatTyped(Pat.Typed scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatVar.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatVar.java
new file mode 100644
index 0000000000..a02de8b0de
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatVar.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Pat;
+
+public class ASTPatVar extends AbstractScalaNode<Pat.Var> {
+
+    public ASTPatVar(Pat.Var scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatWildcard.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatWildcard.java
new file mode 100644
index 0000000000..6f37380aca
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatWildcard.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Pat;
+
+public class ASTPatWildcard extends AbstractScalaNode<Pat.Wildcard> {
+
+    public ASTPatWildcard(Pat.Wildcard scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatXml.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatXml.java
new file mode 100644
index 0000000000..99c8e41bec
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPatXml.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Pat;
+
+public class ASTPatXml extends AbstractScalaNode<Pat.Xml> {
+
+    public ASTPatXml(Pat.Xml scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPkg.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPkg.java
new file mode 100644
index 0000000000..c6185ba53c
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPkg.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Pkg;
+
+public class ASTPkg extends AbstractScalaNode<Pkg> {
+
+    public ASTPkg(Pkg scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPkgObject.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPkgObject.java
new file mode 100644
index 0000000000..d5b8d7b5d0
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTPkgObject.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Pkg;
+
+public class ASTPkgObject extends AbstractScalaNode<Pkg.Object> {
+
+    public ASTPkgObject(Pkg.Object scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTQuasi.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTQuasi.java
new file mode 100644
index 0000000000..847c76faab
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTQuasi.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Tree.Quasi;
+
+public class ASTQuasi extends AbstractScalaNode<Quasi> {
+
+    public ASTQuasi(Quasi scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTSelf.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTSelf.java
new file mode 100644
index 0000000000..a966d57f3f
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTSelf.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Self;
+
+public class ASTSelf extends AbstractScalaNode<Self> {
+
+    public ASTSelf(Self scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTSource.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTSource.java
new file mode 100644
index 0000000000..d80923e86e
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTSource.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Source;
+
+public class ASTSource extends AbstractScalaNode<Source> {
+
+    public ASTSource(Source scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTemplate.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTemplate.java
new file mode 100644
index 0000000000..2c1c79ed7b
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTemplate.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Template;
+
+public class ASTTemplate extends AbstractScalaNode<Template> {
+
+    public ASTTemplate(Template scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermAnnotate.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermAnnotate.java
new file mode 100644
index 0000000000..9f936f27d0
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermAnnotate.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermAnnotate extends AbstractScalaNode<Term.Annotate> {
+
+    public ASTTermAnnotate(Term.Annotate scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermApply.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermApply.java
new file mode 100644
index 0000000000..c889140367
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermApply.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermApply extends AbstractScalaNode<Term.Apply> {
+
+    public ASTTermApply(Term.Apply scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermApplyInfix.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermApplyInfix.java
new file mode 100644
index 0000000000..8903080f20
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermApplyInfix.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermApplyInfix extends AbstractScalaNode<Term.ApplyInfix> {
+
+    public ASTTermApplyInfix(Term.ApplyInfix scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermApplyType.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermApplyType.java
new file mode 100644
index 0000000000..e8c99710da
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermApplyType.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermApplyType extends AbstractScalaNode<Term.ApplyType> {
+
+    public ASTTermApplyType(Term.ApplyType scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermApplyUnary.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermApplyUnary.java
new file mode 100644
index 0000000000..5c7d9611d4
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermApplyUnary.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermApplyUnary extends AbstractScalaNode<Term.ApplyUnary> {
+
+    public ASTTermApplyUnary(Term.ApplyUnary scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermAscribe.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermAscribe.java
new file mode 100644
index 0000000000..97609ae93a
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermAscribe.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermAscribe extends AbstractScalaNode<Term.Ascribe> {
+
+    public ASTTermAscribe(Term.Ascribe scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermAssign.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermAssign.java
new file mode 100644
index 0000000000..79471d7369
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermAssign.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermAssign extends AbstractScalaNode<Term.Assign> {
+
+    public ASTTermAssign(Term.Assign scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermBlock.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermBlock.java
new file mode 100644
index 0000000000..7ac8554d4c
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermBlock.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermBlock extends AbstractScalaNode<Term.Block> {
+
+    public ASTTermBlock(Term.Block scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermDo.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermDo.java
new file mode 100644
index 0000000000..65e9a088ad
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermDo.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermDo extends AbstractScalaNode<Term.Do> {
+
+    public ASTTermDo(Term.Do scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermEta.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermEta.java
new file mode 100644
index 0000000000..c8236e82bf
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermEta.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermEta extends AbstractScalaNode<Term.Eta> {
+
+    public ASTTermEta(Term.Eta scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermFor.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermFor.java
new file mode 100644
index 0000000000..2fcbda2a97
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermFor.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermFor extends AbstractScalaNode<Term.For> {
+
+    public ASTTermFor(Term.For scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermForYield.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermForYield.java
new file mode 100644
index 0000000000..ec8005d2cd
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermForYield.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermForYield extends AbstractScalaNode<Term.ForYield> {
+
+    public ASTTermForYield(Term.ForYield scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermFunction.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermFunction.java
new file mode 100644
index 0000000000..c845b4df69
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermFunction.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermFunction extends AbstractScalaNode<Term.Function> {
+
+    public ASTTermFunction(Term.Function scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermIf.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermIf.java
new file mode 100644
index 0000000000..86ef818b1d
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermIf.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermIf extends AbstractScalaNode<Term.If> {
+
+    public ASTTermIf(Term.If scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermInterpolate.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermInterpolate.java
new file mode 100644
index 0000000000..a4eb9d85b9
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermInterpolate.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermInterpolate extends AbstractScalaNode<Term.Interpolate> {
+
+    public ASTTermInterpolate(Term.Interpolate scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermMatch.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermMatch.java
new file mode 100644
index 0000000000..ce3c3e3b49
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermMatch.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermMatch extends AbstractScalaNode<Term.Match> {
+
+    public ASTTermMatch(Term.Match scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermName.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermName.java
new file mode 100644
index 0000000000..82328f3f93
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermName.java
@@ -0,0 +1,19 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermName extends AbstractScalaNode<Term.Name> {
+
+    public ASTTermName(Term.Name scalaNode) {
+        super(scalaNode);
+    }
+
+    @Override
+    public String getImage() {
+        return getNode().value();
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermNew.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermNew.java
new file mode 100644
index 0000000000..e626548385
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermNew.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermNew extends AbstractScalaNode<Term.New> {
+
+    public ASTTermNew(Term.New scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermNewAnonymous.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermNewAnonymous.java
new file mode 100644
index 0000000000..874e267e80
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermNewAnonymous.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermNewAnonymous extends AbstractScalaNode<Term.NewAnonymous> {
+
+    public ASTTermNewAnonymous(Term.NewAnonymous scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermParam.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermParam.java
new file mode 100644
index 0000000000..e575dcdcf5
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermParam.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermParam extends AbstractScalaNode<Term.Param> {
+
+    public ASTTermParam(Term.Param scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermPartialFunction.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermPartialFunction.java
new file mode 100644
index 0000000000..30e2372ffe
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermPartialFunction.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermPartialFunction extends AbstractScalaNode<Term.PartialFunction> {
+
+    public ASTTermPartialFunction(Term.PartialFunction scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermPlaceholder.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermPlaceholder.java
new file mode 100644
index 0000000000..86d516f5de
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermPlaceholder.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermPlaceholder extends AbstractScalaNode<Term.Placeholder> {
+
+    public ASTTermPlaceholder(Term.Placeholder scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermRepeated.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermRepeated.java
new file mode 100644
index 0000000000..c11185f718
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermRepeated.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermRepeated extends AbstractScalaNode<Term.Repeated> {
+
+    public ASTTermRepeated(Term.Repeated scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermReturn.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermReturn.java
new file mode 100644
index 0000000000..a2ae8f0513
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermReturn.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermReturn extends AbstractScalaNode<Term.Return> {
+
+    public ASTTermReturn(Term.Return scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermSelect.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermSelect.java
new file mode 100644
index 0000000000..3427dd59bb
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermSelect.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermSelect extends AbstractScalaNode<Term.Select> {
+
+    public ASTTermSelect(Term.Select scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermSuper.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermSuper.java
new file mode 100644
index 0000000000..4c4d9accec
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermSuper.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermSuper extends AbstractScalaNode<Term.Super> {
+
+    public ASTTermSuper(Term.Super scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermThis.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermThis.java
new file mode 100644
index 0000000000..dd3931617c
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermThis.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermThis extends AbstractScalaNode<Term.This> {
+
+    public ASTTermThis(Term.This scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermThrow.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermThrow.java
new file mode 100644
index 0000000000..af7a904e78
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermThrow.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermThrow extends AbstractScalaNode<Term.Throw> {
+
+    public ASTTermThrow(Term.Throw scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermTry.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermTry.java
new file mode 100644
index 0000000000..d055f04d65
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermTry.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermTry extends AbstractScalaNode<Term.Try> {
+
+    public ASTTermTry(Term.Try scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermTryWithHandler.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermTryWithHandler.java
new file mode 100644
index 0000000000..1df14a4cb2
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermTryWithHandler.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermTryWithHandler extends AbstractScalaNode<Term.TryWithHandler> {
+
+    public ASTTermTryWithHandler(Term.TryWithHandler scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermTuple.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermTuple.java
new file mode 100644
index 0000000000..bc45ecf280
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermTuple.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermTuple extends AbstractScalaNode<Term.Tuple> {
+
+    public ASTTermTuple(Term.Tuple scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermWhile.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermWhile.java
new file mode 100644
index 0000000000..6b586d433a
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermWhile.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermWhile extends AbstractScalaNode<Term.While> {
+
+    public ASTTermWhile(Term.While scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermXml.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermXml.java
new file mode 100644
index 0000000000..bafdee614a
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTermXml.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Term;
+
+public class ASTTermXml extends AbstractScalaNode<Term.Xml> {
+
+    public ASTTermXml(Term.Xml scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeAnd.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeAnd.java
new file mode 100644
index 0000000000..3a38d5e8c6
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeAnd.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Type;
+
+public class ASTTypeAnd extends AbstractScalaNode<Type.And> {
+
+    public ASTTypeAnd(Type.And scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeAnnotate.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeAnnotate.java
new file mode 100644
index 0000000000..dbaf6482d4
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeAnnotate.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Type;
+
+public class ASTTypeAnnotate extends AbstractScalaNode<Type.Annotate> {
+
+    public ASTTypeAnnotate(Type.Annotate scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeApply.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeApply.java
new file mode 100644
index 0000000000..3a3f8c3eee
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeApply.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Type;
+
+public class ASTTypeApply extends AbstractScalaNode<Type.Apply> {
+
+    public ASTTypeApply(Type.Apply scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeApplyInfix.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeApplyInfix.java
new file mode 100644
index 0000000000..75cf7e134a
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeApplyInfix.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Type;
+
+public class ASTTypeApplyInfix extends AbstractScalaNode<Type.ApplyInfix> {
+
+    public ASTTypeApplyInfix(Type.ApplyInfix scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeBounds.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeBounds.java
new file mode 100644
index 0000000000..9a0e2482a9
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeBounds.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Type;
+
+public class ASTTypeBounds extends AbstractScalaNode<Type.Bounds> {
+
+    public ASTTypeBounds(Type.Bounds scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeByName.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeByName.java
new file mode 100644
index 0000000000..db3ba81910
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeByName.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Type;
+
+public class ASTTypeByName extends AbstractScalaNode<Type.ByName> {
+
+    public ASTTypeByName(Type.ByName scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeExistential.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeExistential.java
new file mode 100644
index 0000000000..dc13a5a78b
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeExistential.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Type;
+
+public class ASTTypeExistential extends AbstractScalaNode<Type.Existential> {
+
+    public ASTTypeExistential(Type.Existential scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeFunction.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeFunction.java
new file mode 100644
index 0000000000..266a67700b
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeFunction.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Type;
+
+public class ASTTypeFunction extends AbstractScalaNode<Type.Function> {
+
+    public ASTTypeFunction(Type.Function scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeImplicitFunction.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeImplicitFunction.java
new file mode 100644
index 0000000000..8eca24502d
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeImplicitFunction.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Type;
+
+public class ASTTypeImplicitFunction extends AbstractScalaNode<Type.ImplicitFunction> {
+
+    public ASTTypeImplicitFunction(Type.ImplicitFunction scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeLambda.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeLambda.java
new file mode 100644
index 0000000000..dd25a3baec
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeLambda.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Type;
+
+public class ASTTypeLambda extends AbstractScalaNode<Type.Lambda> {
+
+    public ASTTypeLambda(Type.Lambda scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeMethod.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeMethod.java
new file mode 100644
index 0000000000..d4bc913dd8
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeMethod.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Type;
+
+public class ASTTypeMethod extends AbstractScalaNode<Type.Method> {
+
+    public ASTTypeMethod(Type.Method scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeName.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeName.java
new file mode 100644
index 0000000000..60aa571455
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeName.java
@@ -0,0 +1,19 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Type;
+
+public class ASTTypeName extends AbstractScalaNode<Type.Name> {
+
+    public ASTTypeName(Type.Name scalaNode) {
+        super(scalaNode);
+    }
+
+    @Override
+    public String getImage() {
+        return getNode().value();
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeOr.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeOr.java
new file mode 100644
index 0000000000..0ed512b9e6
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeOr.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Type;
+
+public class ASTTypeOr extends AbstractScalaNode<Type.Or> {
+
+    public ASTTypeOr(Type.Or scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeParam.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeParam.java
new file mode 100644
index 0000000000..9dabb9cfc4
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeParam.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Type;
+
+public class ASTTypeParam extends AbstractScalaNode<Type.Param> {
+
+    public ASTTypeParam(Type.Param scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypePlaceholder.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypePlaceholder.java
new file mode 100644
index 0000000000..e8ba49f9f4
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypePlaceholder.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Type;
+
+public class ASTTypePlaceholder extends AbstractScalaNode<Type.Placeholder> {
+
+    public ASTTypePlaceholder(Type.Placeholder scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeProject.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeProject.java
new file mode 100644
index 0000000000..4919573df9
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeProject.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Type;
+
+public class ASTTypeProject extends AbstractScalaNode<Type.Project> {
+
+    public ASTTypeProject(Type.Project scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeRefine.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeRefine.java
new file mode 100644
index 0000000000..18f309d59a
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeRefine.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Type;
+
+public class ASTTypeRefine extends AbstractScalaNode<Type.Refine> {
+
+    public ASTTypeRefine(Type.Refine scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeRepeated.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeRepeated.java
new file mode 100644
index 0000000000..72f16e54ec
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeRepeated.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Type;
+
+public class ASTTypeRepeated extends AbstractScalaNode<Type.Repeated> {
+
+    public ASTTypeRepeated(Type.Repeated scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeSelect.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeSelect.java
new file mode 100644
index 0000000000..1571ce5b29
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeSelect.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Type;
+
+public class ASTTypeSelect extends AbstractScalaNode<Type.Select> {
+
+    public ASTTypeSelect(Type.Select scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeSingleton.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeSingleton.java
new file mode 100644
index 0000000000..0a42f0fef9
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeSingleton.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Type;
+
+public class ASTTypeSingleton extends AbstractScalaNode<Type.Singleton> {
+
+    public ASTTypeSingleton(Type.Singleton scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeTuple.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeTuple.java
new file mode 100644
index 0000000000..d151b9ffb1
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeTuple.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Type;
+
+public class ASTTypeTuple extends AbstractScalaNode<Type.Tuple> {
+
+    public ASTTypeTuple(Type.Tuple scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeVar.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeVar.java
new file mode 100644
index 0000000000..0c8dc1a0c2
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeVar.java
@@ -0,0 +1,15 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Type;
+
+public class ASTTypeVar extends AbstractScalaNode<Type.Var> {
+
+    public ASTTypeVar(Type.Var scalaNode) {
+        super(scalaNode);
+    }
+
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeWith.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeWith.java
new file mode 100644
index 0000000000..d40dc10605
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/ASTTypeWith.java
@@ -0,0 +1,14 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import scala.meta.Type;
+
+public class ASTTypeWith extends AbstractScalaNode<Type.With> {
+
+    public ASTTypeWith(Type.With scalaNode) {
+        super(scalaNode);
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/AbstractScalaNode.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/AbstractScalaNode.java
new file mode 100644
index 0000000000..dd2b19b531
--- /dev/null
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/ast/nodes/AbstractScalaNode.java
@@ -0,0 +1,63 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.scala.ast.nodes;
+
+import net.sourceforge.pmd.lang.ast.AbstractNode;
+import net.sourceforge.pmd.lang.scala.ast.ScalaNode;
+import net.sourceforge.pmd.lang.scala.ast.ScalaParserVisitor;
+
+import scala.meta.Tree;
+import scala.meta.inputs.Position;
+
+/**
+ * A Wrapper for translating the Scala Tree Nodes to PMD-compatible Java-base
+ * Nodes.
+ *
+ * @param <T>
+ *            the type of the Scala tree node
+ */
+public class AbstractScalaNode<T extends Tree> extends AbstractNode implements ScalaNode<T> {
+    private final T node;
+
+    /**
+     * Create the node and configure line numbers.
+     * 
+     * @param treeNode
+     *            the scala tree node this node wraps
+     */
+    public AbstractScalaNode(T treeNode) {
+        super(0);
+        node = treeNode;
+        Position pos = node.pos();
+        beginLine = pos.startLine() + 1;
+        endLine = pos.endLine() + 1;
+        beginColumn = pos.startColumn() + 1;
+        endColumn = pos.endColumn() + 1;
+    }
+
+    @Override
+    public Object accept(ScalaParserVisitor visitor, Object data) {
+        return visitor.visit(this, data);
+    }
+
+    @Override
+    public Object childrenAccept(ScalaParserVisitor visitor, Object data) {
+        int numChildren = jjtGetNumChildren();
+        for (int i = 0; i < numChildren; ++i) {
+            ((ScalaNode<?>) jjtGetChild(i)).accept(visitor, data);
+        }
+        return data;
+    }
+
+    @Override
+    public T getNode() {
+        return node;
+    }
+
+    @Override
+    public String getXPathNodeName() {
+        return node.productPrefix().replace(".", "");
+    }
+}
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/rule/ScalaRule.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/rule/ScalaRule.java
index 41fcb0e940..4819b3f9c0 100644
--- a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/rule/ScalaRule.java
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/rule/ScalaRule.java
@@ -11,9 +11,156 @@ import net.sourceforge.pmd.lang.LanguageRegistry;
 import net.sourceforge.pmd.lang.ast.Node;
 import net.sourceforge.pmd.lang.rule.AbstractRule;
 import net.sourceforge.pmd.lang.scala.ScalaLanguageModule;
-import net.sourceforge.pmd.lang.scala.ast.ASTSourceNode;
 import net.sourceforge.pmd.lang.scala.ast.ScalaNode;
 import net.sourceforge.pmd.lang.scala.ast.ScalaParserVisitor;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTCase;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTCtorPrimary;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTCtorSecondary;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDeclDef;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDeclType;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDeclVal;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDeclVar;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDefnClass;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDefnDef;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDefnMacro;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDefnObject;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDefnTrait;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDefnType;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDefnVal;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTDefnVar;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTEnumeratorGenerator;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTEnumeratorGuard;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTEnumeratorVal;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTImport;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTImporteeName;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTImporteeRename;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTImporteeUnimport;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTImporteeWildcard;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTImporter;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTInit;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitBoolean;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitByte;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitChar;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitDouble;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitFloat;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitInt;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitLong;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitNull;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitShort;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitString;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitSymbol;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTLitUnit;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModAbstract;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModAnnot;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModCase;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModContravariant;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModCovariant;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModFinal;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModImplicit;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModInline;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModLazy;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModOverride;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModPrivate;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModProtected;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModSealed;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModValParam;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTModVarParam;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTNameAnonymous;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTNameIndeterminate;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatAlternative;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatBind;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatExtract;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatExtractInfix;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatInterpolate;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatSeqWildcard;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatTuple;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatTyped;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatVar;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatWildcard;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPatXml;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPkg;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTPkgObject;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTQuasi;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTSelf;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTSource;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTemplate;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermAnnotate;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermApply;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermApplyInfix;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermApplyType;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermApplyUnary;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermAscribe;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermAssign;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermBlock;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermDo;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermEta;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermFor;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermForYield;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermFunction;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermIf;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermInterpolate;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermMatch;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermName;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermNew;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermNewAnonymous;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermParam;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermPartialFunction;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermPlaceholder;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermRepeated;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermReturn;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermSelect;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermSuper;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermThis;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermThrow;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermTry;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermTryWithHandler;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermTuple;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermWhile;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTermXml;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeAnd;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeAnnotate;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeApply;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeApplyInfix;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeBounds;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeByName;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeExistential;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeFunction;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeImplicitFunction;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeLambda;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeMethod;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeName;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeOr;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeParam;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypePlaceholder;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeProject;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeRefine;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeRepeated;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeSelect;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeSingleton;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeTuple;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeVar;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTTypeWith;
+
+import scala.meta.Case;
+import scala.meta.Ctor;
+import scala.meta.Decl;
+import scala.meta.Defn;
+import scala.meta.Enumerator;
+import scala.meta.Import;
+import scala.meta.Importee;
+import scala.meta.Importer;
+import scala.meta.Init;
+import scala.meta.Lit;
+import scala.meta.Mod;
+import scala.meta.Name;
+import scala.meta.Pat;
+import scala.meta.Pkg;
+import scala.meta.Self;
+import scala.meta.Source;
+import scala.meta.Template;
+import scala.meta.Term;
+import scala.meta.Tree.Quasi;
+import scala.meta.Type;
 
 /**
  * The default base implementation of a PMD Rule for Scala. Uses the Visitor
@@ -31,20 +178,649 @@ public class ScalaRule extends AbstractRule implements ScalaParserVisitor {
     @Override
     public void apply(List<? extends Node> nodes, RuleContext ctx) {
         for (Node node : nodes) {
-            if (node instanceof ASTSourceNode) {
-                visit((ASTSourceNode) node, ctx);
+            if (node instanceof ASTSource) {
+                visit((ASTSource) node, ctx);
             }
         }
     }
 
     @Override
-    public Object visit(ASTSourceNode node, Object data) {
-        return visit((ScalaNode) node, data);
-    }
-
-    @Override
-    public Object visit(ScalaNode node, Object data) {
+    public Object visit(ScalaNode<?> node, Object data) {
         return node.childrenAccept(this, data);
     }
 
+    @Override
+    public Object visit(ASTSource node, Object data) {
+        return visit((ScalaNode<Source>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTCase node, Object data) {
+        return visit((ScalaNode<Case>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTCtorPrimary node, Object data) {
+        return visit((ScalaNode<Ctor.Primary>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTCtorSecondary node, Object data) {
+        return visit((ScalaNode<Ctor.Secondary>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTDeclDef node, Object data) {
+        return visit((ScalaNode<Decl.Def>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTDeclType node, Object data) {
+        return visit((ScalaNode<Decl.Type>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTDeclVal node, Object data) {
+        return visit((ScalaNode<Decl.Val>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTDeclVar node, Object data) {
+        return visit((ScalaNode<Decl.Var>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTDefnClass node, Object data) {
+        return visit((ScalaNode<Defn.Class>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTDefnDef node, Object data) {
+        return visit((ScalaNode<Defn.Def>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTDefnMacro node, Object data) {
+        return visit((ScalaNode<Defn.Macro>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTDefnObject node, Object data) {
+        return visit((ScalaNode<Defn.Object>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTDefnTrait node, Object data) {
+        return visit((ScalaNode<Defn.Trait>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTDefnType node, Object data) {
+        return visit((ScalaNode<Defn.Type>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTDefnVal node, Object data) {
+        return visit((ScalaNode<Defn.Val>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTDefnVar node, Object data) {
+        return visit((ScalaNode<Defn.Var>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTEnumeratorGenerator node, Object data) {
+        return visit((ScalaNode<Enumerator.Generator>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTEnumeratorGuard node, Object data) {
+        return visit((ScalaNode<Enumerator.Guard>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTEnumeratorVal node, Object data) {
+        return visit((ScalaNode<Enumerator.Val>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTImport node, Object data) {
+        return visit((ScalaNode<Import>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTImporteeName node, Object data) {
+        return visit((ScalaNode<Importee.Name>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTImporteeRename node, Object data) {
+        return visit((ScalaNode<Importee.Rename>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTImporteeUnimport node, Object data) {
+        return visit((ScalaNode<Importee.Unimport>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTImporteeWildcard node, Object data) {
+        return visit((ScalaNode<Importee.Wildcard>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTImporter node, Object data) {
+        return visit((ScalaNode<Importer>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTInit node, Object data) {
+        return visit((ScalaNode<Init>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTLitBoolean node, Object data) {
+        return visit((ScalaNode<Lit.Boolean>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTLitByte node, Object data) {
+        return visit((ScalaNode<Lit.Byte>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTLitChar node, Object data) {
+        return visit((ScalaNode<Lit.Char>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTLitDouble node, Object data) {
+        return visit((ScalaNode<Lit.Double>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTLitFloat node, Object data) {
+        return visit((ScalaNode<Lit.Float>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTLitInt node, Object data) {
+        return visit((ScalaNode<Lit.Int>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTLitLong node, Object data) {
+        return visit((ScalaNode<Lit.Long>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTLitNull node, Object data) {
+        return visit((ScalaNode<Lit.Null>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTLitShort node, Object data) {
+        return visit((ScalaNode<Lit.Short>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTLitString node, Object data) {
+        return visit((ScalaNode<Lit.String>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTLitSymbol node, Object data) {
+        return visit((ScalaNode<Lit.Symbol>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTLitUnit node, Object data) {
+        return visit((ScalaNode<Lit.Unit>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTModAbstract node, Object data) {
+        return visit((ScalaNode<Mod.Abstract>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTModAnnot node, Object data) {
+        return visit((ScalaNode<Mod.Annot>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTModCase node, Object data) {
+        return visit((ScalaNode<Mod.Case>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTModContravariant node, Object data) {
+        return visit((ScalaNode<Mod.Contravariant>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTModCovariant node, Object data) {
+        return visit((ScalaNode<Mod.Covariant>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTModFinal node, Object data) {
+        return visit((ScalaNode<Mod.Final>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTModImplicit node, Object data) {
+        return visit((ScalaNode<Mod.Implicit>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTModInline node, Object data) {
+        return visit((ScalaNode<Mod.Inline>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTModLazy node, Object data) {
+        return visit((ScalaNode<Mod.Lazy>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTModOverride node, Object data) {
+        return visit((ScalaNode<Mod.Override>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTModPrivate node, Object data) {
+        return visit((ScalaNode<Mod.Private>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTModProtected node, Object data) {
+        return visit((ScalaNode<Mod.Protected>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTModSealed node, Object data) {
+        return visit((ScalaNode<Mod.Sealed>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTModValParam node, Object data) {
+        return visit((ScalaNode<Mod.ValParam>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTModVarParam node, Object data) {
+        return visit((ScalaNode<Mod.VarParam>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTNameAnonymous node, Object data) {
+        return visit((ScalaNode<Name.Anonymous>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTNameIndeterminate node, Object data) {
+        return visit((ScalaNode<Name.Indeterminate>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTPatAlternative node, Object data) {
+        return visit((ScalaNode<Pat.Alternative>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTPatBind node, Object data) {
+        return visit((ScalaNode<Pat.Bind>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTPatExtract node, Object data) {
+        return visit((ScalaNode<Pat.Extract>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTPatExtractInfix node, Object data) {
+        return visit((ScalaNode<Pat.ExtractInfix>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTPatInterpolate node, Object data) {
+        return visit((ScalaNode<Pat.Interpolate>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTPatSeqWildcard node, Object data) {
+        return visit((ScalaNode<Pat.SeqWildcard>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTPatTuple node, Object data) {
+        return visit((ScalaNode<Pat.Tuple>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTPatTyped node, Object data) {
+        return visit((ScalaNode<Pat.Typed>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTPatVar node, Object data) {
+        return visit((ScalaNode<Pat.Var>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTPatWildcard node, Object data) {
+        return visit((ScalaNode<Pat.Wildcard>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTPatXml node, Object data) {
+        return visit((ScalaNode<Pat.Xml>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTPkg node, Object data) {
+        return visit((ScalaNode<Pkg>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTPkgObject node, Object data) {
+        return visit((ScalaNode<Pkg.Object>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTQuasi node, Object data) {
+        return visit((ScalaNode<Quasi>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTSelf node, Object data) {
+        return visit((ScalaNode<Self>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTemplate node, Object data) {
+        return visit((ScalaNode<Template>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermAnnotate node, Object data) {
+        return visit((ScalaNode<Term.Annotate>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermApply node, Object data) {
+        return visit((ScalaNode<Term.Apply>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermApplyInfix node, Object data) {
+        return visit((ScalaNode<Term.ApplyInfix>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermApplyType node, Object data) {
+        return visit((ScalaNode<Term.ApplyType>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermApplyUnary node, Object data) {
+        return visit((ScalaNode<Term.ApplyUnary>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermAscribe node, Object data) {
+        return visit((ScalaNode<Term.Ascribe>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermAssign node, Object data) {
+        return visit((ScalaNode<Term.Assign>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermBlock node, Object data) {
+        return visit((ScalaNode<Term.Block>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermDo node, Object data) {
+        return visit((ScalaNode<Term.Do>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermEta node, Object data) {
+        return visit((ScalaNode<Term.Eta>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermFor node, Object data) {
+        return visit((ScalaNode<Term.For>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermForYield node, Object data) {
+        return visit((ScalaNode<Term.ForYield>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermFunction node, Object data) {
+        return visit((ScalaNode<Term.Function>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermIf node, Object data) {
+        return visit((ScalaNode<Term.If>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermInterpolate node, Object data) {
+        return visit((ScalaNode<Term.Interpolate>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermMatch node, Object data) {
+        return visit((ScalaNode<Term.Match>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermName node, Object data) {
+        return visit((ScalaNode<Term.Name>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermNewAnonymous node, Object data) {
+        return visit((ScalaNode<Term.NewAnonymous>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermNew node, Object data) {
+        return visit((ScalaNode<Term.New>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermParam node, Object data) {
+        return visit((ScalaNode<Term.Param>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermPartialFunction node, Object data) {
+        return visit((ScalaNode<Term.PartialFunction>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermPlaceholder node, Object data) {
+        return visit((ScalaNode<Term.Placeholder>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermRepeated node, Object data) {
+        return visit((ScalaNode<Term.Repeated>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermReturn node, Object data) {
+        return visit((ScalaNode<Term.Return>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermSelect node, Object data) {
+        return visit((ScalaNode<Term.Select>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermSuper node, Object data) {
+        return visit((ScalaNode<Term.Super>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermThis node, Object data) {
+        return visit((ScalaNode<Term.This>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermThrow node, Object data) {
+        return visit((ScalaNode<Term.Throw>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermTry node, Object data) {
+        return visit((ScalaNode<Term.Try>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermTryWithHandler node, Object data) {
+        return visit((ScalaNode<Term.TryWithHandler>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermTuple node, Object data) {
+        return visit((ScalaNode<Term.Tuple>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermWhile node, Object data) {
+        return visit((ScalaNode<Term.While>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTermXml node, Object data) {
+        return visit((ScalaNode<Term.Xml>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeAnd node, Object data) {
+        return visit((ScalaNode<Type.And>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeAnnotate node, Object data) {
+        return visit((ScalaNode<Type.Annotate>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeApply node, Object data) {
+        return visit((ScalaNode<Type.Apply>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeApplyInfix node, Object data) {
+        return visit((ScalaNode<Type.ApplyInfix>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeBounds node, Object data) {
+        return visit((ScalaNode<Type.Bounds>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeByName node, Object data) {
+        return visit((ScalaNode<Type.ByName>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeExistential node, Object data) {
+        return visit((ScalaNode<Type.Existential>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeFunction node, Object data) {
+        return visit((ScalaNode<Type.Function>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeImplicitFunction node, Object data) {
+        return visit((ScalaNode<Type.ImplicitFunction>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeLambda node, Object data) {
+        return visit((ScalaNode<Type.Lambda>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeMethod node, Object data) {
+        return visit((ScalaNode<Type.Method>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeName node, Object data) {
+        return visit((ScalaNode<Type.Name>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeOr node, Object data) {
+        return visit((ScalaNode<Type.Or>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeParam node, Object data) {
+        return visit((ScalaNode<Type.Param>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypePlaceholder node, Object data) {
+        return visit((ScalaNode<Type.Placeholder>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeProject node, Object data) {
+        return visit((ScalaNode<Type.Project>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeRefine node, Object data) {
+        return visit((ScalaNode<Type.Refine>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeRepeated node, Object data) {
+        return visit((ScalaNode<Type.Repeated>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeSelect node, Object data) {
+        return visit((ScalaNode<Type.Select>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeSingleton node, Object data) {
+        return visit((ScalaNode<Type.Singleton>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeTuple node, Object data) {
+        return visit((ScalaNode<Type.Tuple>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeVar node, Object data) {
+        return visit((ScalaNode<Type.Var>) node, data);
+    }
+
+    @Override
+    public Object visit(ASTTypeWith node, Object data) {
+        return visit((ScalaNode<Type.With>) node, data);
+    }
 }
diff --git a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/rule/ScalaRuleChainVisitor.java b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/rule/ScalaRuleChainVisitor.java
index 377e6d59bc..5d483ca966 100644
--- a/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/rule/ScalaRuleChainVisitor.java
+++ b/pmd-scala/src/main/java/net/sourceforge/pmd/lang/scala/rule/ScalaRuleChainVisitor.java
@@ -11,11 +11,10 @@ import net.sourceforge.pmd.RuleContext;
 import net.sourceforge.pmd.lang.ast.Node;
 import net.sourceforge.pmd.lang.rule.AbstractRuleChainVisitor;
 import net.sourceforge.pmd.lang.rule.XPathRule;
-import net.sourceforge.pmd.lang.scala.ast.ASTSourceNode;
 import net.sourceforge.pmd.lang.scala.ast.ScalaNode;
 import net.sourceforge.pmd.lang.scala.ast.ScalaParserVisitor;
 import net.sourceforge.pmd.lang.scala.ast.ScalaParserVisitorAdapter;
-import net.sourceforge.pmd.lang.scala.ast.ScalaWrapperNode;
+import net.sourceforge.pmd.lang.scala.ast.nodes.ASTSource;
 
 /**
  * A Rule Chain visitor for Scala.
@@ -24,11 +23,11 @@ public class ScalaRuleChainVisitor extends AbstractRuleChainVisitor {
 
     @Override
     protected void visit(Rule rule, Node node, RuleContext ctx) {
-        // Rule better either be a JavaParserVisitor, or a XPathRule
+        // Rule better either be a ScalaParserVisitor, or a XPathRule
         if (rule instanceof XPathRule) {
             ((XPathRule) rule).evaluate(node, ctx);
         } else {
-            ((ScalaWrapperNode) node).accept((ScalaParserVisitorAdapter) rule, ctx);
+            ((ScalaNode<?>) node).accept((ScalaParserVisitorAdapter) rule, ctx);
         }
     }
 
@@ -36,13 +35,13 @@ public class ScalaRuleChainVisitor extends AbstractRuleChainVisitor {
     protected void indexNodes(List<Node> nodes, RuleContext ctx) {
         ScalaParserVisitor visitor = new ScalaParserVisitorAdapter() {
             @Override
-            public Object visit(ScalaNode node, Object data) {
+            public Object visit(ScalaNode<?> node, Object data) {
                 indexNode(node);
                 return super.visit(node, data);
             }
         };
         for (final Node node : nodes) {
-            visitor.visit((ASTSourceNode) node, ctx);
+            visitor.visit((ASTSource) node, ctx);
         }
     }