diff --git a/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/errorprone/UnusedAssignmentRule.java b/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/errorprone/UnusedAssignmentRule.java
new file mode 100644
index 0000000000..6765027c6c
--- /dev/null
+++ b/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/errorprone/UnusedAssignmentRule.java
@@ -0,0 +1,235 @@
+/*
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.java.rule.errorprone;
+
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import net.sourceforge.pmd.lang.java.ast.ASTAssignmentOperator;
+import net.sourceforge.pmd.lang.java.ast.ASTBlock;
+import net.sourceforge.pmd.lang.java.ast.ASTExpression;
+import net.sourceforge.pmd.lang.java.ast.ASTMethodDeclaration;
+import net.sourceforge.pmd.lang.java.ast.ASTName;
+import net.sourceforge.pmd.lang.java.ast.ASTPrimaryExpression;
+import net.sourceforge.pmd.lang.java.ast.ASTPrimaryPrefix;
+import net.sourceforge.pmd.lang.java.ast.ASTPrimarySuffix;
+import net.sourceforge.pmd.lang.java.ast.ASTStatementExpression;
+import net.sourceforge.pmd.lang.java.ast.ASTVariableDeclarator;
+import net.sourceforge.pmd.lang.java.ast.ASTVariableInitializer;
+import net.sourceforge.pmd.lang.java.ast.JavaNode;
+import net.sourceforge.pmd.lang.java.ast.JavaParserVisitorAdapter;
+import net.sourceforge.pmd.lang.java.rule.AbstractJavaRule;
+import net.sourceforge.pmd.lang.java.rule.errorprone.UnusedAssignmentRule.LivenessVisitor.ScopeData;
+import net.sourceforge.pmd.lang.java.rule.errorprone.UnusedAssignmentRule.LivenessVisitor.ScopeData.AssignmentEntry;
+import net.sourceforge.pmd.lang.java.symboltable.ClassScope;
+import net.sourceforge.pmd.lang.java.symboltable.VariableNameDeclaration;
+import net.sourceforge.pmd.lang.symboltable.Scope;
+
+public class UnusedAssignmentRule extends AbstractJavaRule {
+
+
+    @Override
+    public Object visit(ASTMethodDeclaration node, Object data) {
+
+        ScopeData bodyData = new ScopeData();
+
+        //        for (ASTFormalParameter param : node.getFormalParameters()) {
+        //            bodyData.varsThatMustBeUsed.add(param.getVariableDeclaratorId().getNameDeclaration());
+        //        }
+
+        ScopeData endData = (ScopeData) node.getBody().jjtAccept(new LivenessVisitor(), bodyData);
+
+        if (endData.usedAssignments.size() < endData.allAssignments.size()) {
+            HashSet<AssignmentEntry> unused = new HashSet<>(endData.allAssignments);
+            unused.removeAll(endData.usedAssignments);
+            // allAssignments is the unused assignments now
+
+            for (AssignmentEntry entry : unused) {
+                addViolationWithMessage(data, entry.rhs, "The value assigned to variable ''{0}'' is never used", new Object[] {entry.var.getImage()});
+            }
+        }
+        //        if (!endData.varsThatMustBeUsed.isEmpty()) {
+        //            HashSet<VariableNameDeclaration> assignedVars = new HashSet<>();
+        //            for (AssignmentEntry assignment : endData.allAssignments) {
+        //                assignedVars.add(assignment.var);
+        //            }
+
+        //            for (VariableNameDeclaration var : endData.varsThatMustBeUsed) {
+        //                if (assignedVars.contains(var)) {
+        //                    addViolationWithMessage(data, var.getNode(), "The variable ''{0}'' is assigned, but never accessed", new Object[] {var.getImage()});
+        //                } else {
+        //                    addViolationWithMessage(data, var.getNode(), "The variable ''{0}'' is never used", new Object[] {var.getImage()});
+        //                }
+        //            }
+        //        }
+
+        return super.visit(node, data);
+    }
+
+    static class LivenessVisitor extends JavaParserVisitorAdapter {
+
+        void bar(int i) {
+            int j = 0;
+            int z = 0;
+            if (i < 10) {
+                j = i;
+            }
+        }
+
+        static class ScopeData {
+
+            final Set<VariableNameDeclaration> varsThatMustBeUsed = new HashSet<>();
+
+            final Set<AssignmentEntry> allAssignments = new HashSet<>();
+            final Set<AssignmentEntry> usedAssignments = new HashSet<>();
+
+            final Map<VariableNameDeclaration, List<AssignmentEntry>> liveAssignments = new HashMap<>();
+
+            static class AssignmentEntry {
+
+                final VariableNameDeclaration var;
+                final JavaNode rhs;
+
+                AssignmentEntry(VariableNameDeclaration var, JavaNode rhs) {
+                    this.var = var;
+                    this.rhs = rhs;
+                }
+            }
+
+            public void assign(VariableNameDeclaration var, JavaNode rhs) {
+                AssignmentEntry entry = new AssignmentEntry(var, rhs);
+                liveAssignments.put(var, Collections.singletonList(entry)); // kills the previous value
+                allAssignments.add(entry);
+            }
+
+            public void use(VariableNameDeclaration var) {
+                List<AssignmentEntry> live = liveAssignments.get(var);
+                // may be null for implicit assignments, like method parameter
+                if (live != null) {
+                    usedAssignments.addAll(live);
+                }
+            }
+        }
+
+
+        @Override
+        public Object visit(ASTBlock node, Object data) {
+
+            for (JavaNode child : node.children()) {
+                // each statement's output is passed as input to the next
+                data = child.jjtAccept(this, data);
+            }
+
+            return data;
+        }
+
+        @Override
+        public Object visit(ASTVariableDeclarator node, Object data) {
+            VariableNameDeclaration var = node.getVariableId().getNameDeclaration();
+            ASTVariableInitializer rhs = node.getInitializer();
+            if (rhs != null) {
+                rhs.jjtAccept(this, data);
+                ((ScopeData) data).assign(var, rhs);
+            }
+            return data;
+        }
+
+        @Override
+        public Object visit(ASTExpression node, Object data) {
+            return checkAssignment(node, data);
+        }
+
+        @Override
+        public Object visit(ASTStatementExpression node, Object data) {
+            return checkAssignment(node, data);
+        }
+
+        public Object checkAssignment(JavaNode node, Object data) {
+            if (node.getNumChildren() == 3) {
+                // assignment
+                assert node.getChild(1) instanceof ASTAssignmentOperator;
+
+                // visit the rhs as it is evaluated before
+                ASTExpression rhs = (ASTExpression) node.getChild(2);
+                rhs.jjtAccept(this, data);
+
+                VariableNameDeclaration lhsVar = getLhsVar(node.getChild(0), true);
+                if (lhsVar != null) {
+                    ((ScopeData) data).assign(lhsVar, rhs);
+                } else {
+                    node.getChild(0).jjtAccept(this, data);
+                }
+                return data;
+            } else {
+                return super.visit(node, data);
+            }
+        }
+
+        @Override
+        public Object visit(ASTPrimaryExpression node, Object data) {
+            super.visit(node, data); // visit subexpressions
+
+            VariableNameDeclaration var = getLhsVar(node, false);
+            if (var != null) {
+                ((ScopeData) data).use(var);
+            }
+            return data;
+        }
+
+        private VariableNameDeclaration getLhsVar(JavaNode primary, boolean inLhs) {
+            if (primary instanceof ASTPrimaryExpression) {
+                ASTPrimaryPrefix prefix = (ASTPrimaryPrefix) primary.getChild(0);
+
+                if (prefix.usesThisModifier()) {
+                    if (primary.getNumChildren() != 2 && inLhs) {
+                        return null;
+                    }
+                    ASTPrimarySuffix suffix = (ASTPrimarySuffix) primary.getChild(1);
+                    if (suffix.isArguments() || suffix.isArrayDereference()) {
+                        return null;
+                    }
+                    return findVar(primary.getScope(), true, suffix.getImage());
+                } else {
+                    if (inLhs && primary.getNumChildren() > 1) {
+                        return null;
+                    }
+
+                    if (prefix.getChild(0) instanceof ASTName) {
+                        return findVar(prefix.getScope(), false, prefix.getChild(0).getImage());
+                    }
+                }
+            }
+
+            return null;
+        }
+
+        private VariableNameDeclaration findVar(Scope scope, boolean isThis, String name) {
+            if (name == null) {
+                return null;
+            }
+            if (isThis) {
+                scope = scope.getEnclosingScope(ClassScope.class);
+            }
+
+            while (scope != null) {
+                for (VariableNameDeclaration decl : scope.getDeclarations(VariableNameDeclaration.class).keySet()) {
+                    if (decl.getImage().equals(name)) {
+                        return decl;
+                    }
+                }
+
+                scope = scope.getParent();
+            }
+
+            return null;
+        }
+    }
+
+}
diff --git a/pmd-java/src/main/resources/category/java/errorprone.xml b/pmd-java/src/main/resources/category/java/errorprone.xml
index 8033820e7f..fb0559eef5 100644
--- a/pmd-java/src/main/resources/category/java/errorprone.xml
+++ b/pmd-java/src/main/resources/category/java/errorprone.xml
@@ -3276,6 +3276,25 @@ public String convert(int x) {
         </example>
     </rule>
 
+
+    <rule name="UnusedAssignment"
+          language="java"
+          since="6.26.0"
+          message="The value assigned to variable ''{0}'' is never used"
+          class="net.sourceforge.pmd.lang.java.rule.errorprone.UnusedAssignmentRule"
+          externalInfoUrl="${pmd.website.baseurl}/pmd_rules_java_errorprone.html#unusedassignment">
+        <description>
+            TODO
+        </description>
+        <priority>3</priority>
+        <example>
+        <![CDATA[
+            // TODO
+        ]]>
+        </example>
+    </rule>
+
+
     <rule name="UnusedNullCheckInEquals"
           language="java"
           since="3.5"
diff --git a/pmd-java/src/test/java/net/sourceforge/pmd/lang/java/rule/errorprone/UnusedAssignmentTest.java b/pmd-java/src/test/java/net/sourceforge/pmd/lang/java/rule/errorprone/UnusedAssignmentTest.java
new file mode 100644
index 0000000000..89ddb757ae
--- /dev/null
+++ b/pmd-java/src/test/java/net/sourceforge/pmd/lang/java/rule/errorprone/UnusedAssignmentTest.java
@@ -0,0 +1,11 @@
+/**
+ * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
+ */
+
+package net.sourceforge.pmd.lang.java.rule.errorprone;
+
+import net.sourceforge.pmd.testframework.PmdRuleTst;
+
+public class UnusedAssignmentTest extends PmdRuleTst {
+    // no additional unit tests
+}
diff --git a/pmd-java/src/test/resources/net/sourceforge/pmd/lang/java/rule/errorprone/xml/UnusedAssignment.xml b/pmd-java/src/test/resources/net/sourceforge/pmd/lang/java/rule/errorprone/xml/UnusedAssignment.xml
new file mode 100644
index 0000000000..4b62dc8493
--- /dev/null
+++ b/pmd-java/src/test/resources/net/sourceforge/pmd/lang/java/rule/errorprone/xml/UnusedAssignment.xml
@@ -0,0 +1,375 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<test-data
+    xmlns="http://pmd.sourceforge.net/rule-tests"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://pmd.sourceforge.net/rule-tests http://pmd.sourceforge.net/rule-tests_1_0_0.xsd">
+
+<!--    <test-code>-->
+<!--        <description>ok</description>-->
+<!--        <expected-problems>0</expected-problems>-->
+<!--        <code><![CDATA[-->
+<!--public class Foo {-->
+<!--    void bar(int b) {-->
+<!--        for (int i = 0; i < 10; i++) {-->
+<!--            throw new Exception();-->
+<!--        }-->
+<!--    }-->
+<!--}-->
+<!--        ]]></code>-->
+<!--    </test-code>-->
+
+    <test-code>
+        <description>DD anomaly</description>
+        <expected-problems>1</expected-problems>
+        <code><![CDATA[
+public class Foo {
+    void bar() {
+        int i=0;
+        i=1;
+        if (i==2) {}
+    }
+}
+        ]]></code>
+    </test-code>
+
+    <test-code>
+        <description>DU anomaly</description>
+        <expected-problems>1</expected-problems>
+        <code><![CDATA[
+public class Foo {
+    void bar() {
+        int i=0;
+    }
+}
+        ]]></code>
+    </test-code>
+
+    <test-code>
+        <description>UR anomaly</description>
+        <expected-problems>0</expected-problems>
+        <code><![CDATA[
+public class Foo {
+    void bar() {
+        int i;
+        if (i == 0) {}
+    }
+}
+        ]]></code>
+    </test-code>
+
+    <test-code>
+        <description>more komplex anomalysis</description>
+        <expected-problems>4</expected-problems>
+        <code><![CDATA[
+public class Foo {
+    void bar(int i) {
+        int j = 0;
+        int z = 0;
+        if (i < 10) {
+            j = i;
+        }
+    }
+}
+        ]]></code>
+    </test-code>
+
+    <test-code>
+        <description>#1393 PMD hanging during DataflowAnomalyAnalysis</description>
+        <!-- Note: due to https://sourceforge.net/p/pmd/bugs/1383/ the 3 problems are false positives!  -->
+        <expected-problems>3</expected-problems>
+        <code><![CDATA[
+public class LoopTest {
+    public static void main(String[] args) {
+        int[] a = {1,2,3};
+        int[] b = {4,5,6};
+        int[] c = {7,8,9};
+        for (int i : a) {
+            if (i == 0) {
+                break;
+            } else {
+                boolean fail = false;
+                for (int j : b) {
+                    boolean match = false;
+                    for (int k : c) {
+                        if (k == 42) {
+                            match = true;
+                        }
+                    }
+                    if (!match) {
+                        fail = true;
+                    }
+                }
+            }
+        }
+    }
+}
+        ]]></code>
+    </test-code>
+
+    <test-code>
+        <description>#408 Assert statements causing </description>
+        <expected-problems>0</expected-problems>
+        <code><![CDATA[
+public class AssertTest {
+    public void test() {
+        final String s = "";
+        assert(s != null);
+
+        System.out.println(s);
+
+        final Double d = 9;
+        assert(d != null);
+
+        System.out.println(d);
+
+        final String k = "k";
+        assert(k != null);
+
+        System.out.println(k);
+    }
+}
+        ]]></code>
+    </test-code>
+
+    <test-code>
+        <description>#1905 [java] DataflowAnomalyAnalysis Rule in right order : Case 1. DU-Anomaly(b)</description>
+        <expected-problems>1</expected-problems>
+        <expected-linenumbers>6</expected-linenumbers>
+        <expected-messages>
+            <message>Found 'DU'-anomaly for variable 'b' (lines '6'-'7').</message>
+        </expected-messages>
+        <code><![CDATA[
+class Test{
+    public static void main(String[] args){
+        int a = 0 ;
+        int b = 0 ;
+        a = a + b ;
+        b = a + b ;
+    }
+}
+        ]]></code>
+    </test-code>
+
+    <test-code>
+        <description>#1905 [java] DataflowAnomalyAnalysis Rule in right order : Case 2. DU-Anomaly(a)</description>
+        <expected-problems>2</expected-problems>
+        <expected-linenumbers>3,5</expected-linenumbers>
+        <expected-messages>
+            <message>Found 'DU'-anomaly for variable 'a' (lines '3'-'7').</message>
+            <message>Found 'DU'-anomaly for variable 'a' (lines '5'-'7').</message>
+        </expected-messages>
+        <code><![CDATA[
+class Test{
+    public static void main(String[] args){
+        int a = 0 ;
+        for(int i = 0 ; i <= 10; i ++){
+            a = a+3;
+        }
+    }
+}
+        ]]></code>
+    </test-code>
+
+    <test-code regressionTest="false">
+        <description>#1905 [java] DataflowAnomalyAnalysis Rule in right order : Case 3. DU-Anomaly(a)</description>
+        <expected-problems>1</expected-problems>
+        <expected-linenumbers>5</expected-linenumbers>
+        <expected-messages>
+            <message>Found 'DU'-anomaly for variable 'a' (lines '5'-'7').</message>
+        </expected-messages>
+        <code><![CDATA[
+class Test{
+    public static void main(String[] args){
+        int[] b = new int[10];
+        for(int a : b){
+            a = a+3;
+        }
+    }
+}
+        ]]></code>
+    </test-code>
+
+    <test-code>
+        <description>#1905 [java] DataflowAnomalyAnalysis Rule in right order : Case 4. DU-Anomaly(a)</description>
+        <expected-problems>2</expected-problems>
+        <expected-linenumbers>3,6</expected-linenumbers>
+        <expected-messages>
+            <message>Found 'DU'-anomaly for variable 'a' (lines '3'-'9').</message>
+            <message>Found 'DU'-anomaly for variable 'a' (lines '6'-'9').</message>
+        </expected-messages>
+        <code><![CDATA[
+class Test{
+    public static void main(String[] args){
+        int a = 0 ;
+        int i = 0 ;
+        while(i < 30){
+            a = a+3;
+            i += 3;
+        }
+    }
+}
+        ]]></code>
+    </test-code>
+
+    <test-code>
+        <description>#1905 [java] DataflowAnomalyAnalysis Rule in right order : Case 5. DU-Anomaly(a)</description>
+        <expected-problems>1</expected-problems>
+        <expected-linenumbers>6</expected-linenumbers>
+        <expected-messages>
+            <message>Found 'DU'-anomaly for variable 'a' (lines '6'-'9').</message>
+        </expected-messages>
+        <code><![CDATA[
+class Test{
+    public static void main(String[] args){
+        int a = 0 ;
+        int i = 0 ;
+        do {
+            a = a+3;
+            i += 3;
+        } while (i < 30);
+   }
+}
+        ]]></code>
+    </test-code>
+
+    <test-code>
+        <description>#1905 [java] DataflowAnomalyAnalysis Rule in right order : Case 6. DU-Anomaly(a)</description>
+        <expected-problems>4</expected-problems>
+        <expected-linenumbers>6,8,10,12</expected-linenumbers>
+        <expected-messages>
+            <message>Found 'DU'-anomaly for variable 'a' (lines '6'-'14').</message>
+            <message>Found 'DU'-anomaly for variable 'a' (lines '8'-'14').</message>
+            <message>Found 'DU'-anomaly for variable 'a' (lines '10'-'14').</message>
+            <message>Found 'DU'-anomaly for variable 'a' (lines '12'-'14').</message>
+        </expected-messages>
+        <code><![CDATA[
+class Test{
+    public static void main(String[] args){
+        int a = 0 ;
+        int i = 0 ;
+        switch(i){
+            case 1 : a = a+1;
+            break;
+            case 2 : a = a+2;
+            break;
+            case 3 : a = a+3;
+            break;
+            default : a = a + 0;
+        }
+    }
+}
+        ]]></code>
+    </test-code>
+
+    <test-code>
+        <description>#1905 [java] DataflowAnomalyAnalysis Rule in right order : Case 7. DU-Anomaly(a)</description>
+        <expected-problems>1</expected-problems>
+        <expected-linenumbers>9</expected-linenumbers>
+        <expected-messages>
+            <message>Found 'DU'-anomaly for variable 'a' (lines '9'-'11').</message>
+        </expected-messages>
+        <code><![CDATA[
+class Test{
+    public static void main(String[] args){
+        int a = 0 ;
+        int i = 0 ;
+        switch(i){
+            case 1 : a = a+1;
+            case 2 : a = a+2;
+            case 3 : a = a+3;
+            default : a = a + 0;
+        }
+    }
+}
+        ]]></code>
+    </test-code>
+
+    <test-code>
+        <description>#1905 [java] DataflowAnomalyAnalysis Rule in right order : Case 9. DU-Anomaly(t1)</description>
+        <expected-problems>1</expected-problems>
+        <expected-linenumbers>5</expected-linenumbers>
+        <expected-messages>
+            <message>Found 'DU'-anomaly for variable 't1' (lines '5'-'6').</message>
+        </expected-messages>
+        <code><![CDATA[
+class Test{
+    public static void main(String[] args){
+        int t1 = 0 ;
+        Test2 test = new Test2() ;
+        t1 = test.simpleTest(t1) ;
+    }
+}
+        ]]></code>
+    </test-code>
+
+    <test-code>
+        <description>#1905 [java] DataflowAnomalyAnalysis Rule in right order : Case 12. DU-Anomaly(t1)</description>
+        <expected-problems>1</expected-problems>
+        <expected-linenumbers>6</expected-linenumbers>
+        <expected-messages>
+            <message>Found 'DU'-anomaly for variable 't1' (lines '6'-'7').</message>
+        </expected-messages>
+        <code><![CDATA[
+class Test{
+    public static void main(String[] args){
+        int t1 = 0 ;
+        int t2 = 0 ;
+        Test2 test = new Test2();
+        if((t1 = test.simpleTest(t1)) == t2);
+    }
+}
+        ]]></code>
+    </test-code>
+
+    <test-code>
+        <description>#1905 [java] DataflowAnomalyAnalysis Rule in right order : Case 13</description>
+        <expected-problems>0</expected-problems>
+        <code><![CDATA[
+class Test{
+    public static void main(String[] args){
+        int t1 = 0 ;
+
+        Test2 test = new Test2();
+        if( (t1 = test.simpleTest(t1)) == t1);
+   }
+}
+        ]]></code>
+    </test-code>
+
+    <test-code>
+        <description>#1905 [java] DataflowAnomalyAnalysis Rule in right order : Case 14. DU-Anomaly(t1, t2)</description>
+        <expected-problems>2</expected-problems>
+        <expected-linenumbers>4,6</expected-linenumbers>
+        <expected-messages>
+            <message>Found 'DU'-anomaly for variable 't2' (lines '4'-'7').</message>
+            <message>Found 'DU'-anomaly for variable 't1' (lines '6'-'7').</message>
+        </expected-messages>
+        <code><![CDATA[
+class Test{
+    public static void main(String[] args){
+        int t1 = 0;
+        int t2 = 0;
+        Test2 test = new Test2() ;
+        if( t1 == (t1 = test.simpleTest(t1))) ;
+   }
+}
+        ]]></code>
+    </test-code>
+
+    <test-code>
+        <description>#1749 DD False Positive in DataflowAnomalyAnalysis</description>
+        <expected-problems>1</expected-problems>
+        <expected-linenumbers>4</expected-linenumbers>
+        <expected-messages>
+            <message>Found 'DU'-anomaly for variable 'a' (lines '4'-'5').</message>
+        </expected-messages>
+        <code><![CDATA[
+public class Test {
+    public void test(){
+        int a = 0;
+        a = a + 3;
+    }
+}
+        ]]></code>
+    </test-code>
+</test-data>