diff --git a/src/common.h b/src/common.h
index a3403b5..9392b5c 100644
--- a/src/common.h
+++ b/src/common.h
@@ -183,6 +183,7 @@
 
 #define LY_VCODE_INVAL_MINMAX   LYVE_SEMANTICS, "Invalid combination of min-elements and max-elements: min value %u is bigger than the max value %u."
 #define LY_VCODE_CIRC_WHEN      LYVE_SEMANTICS, "When condition of \"%s\" includes a self-reference (referenced by when of \"%s\")."
+#define LY_VCODE_DUMMY_WHEN     LYVE_SEMANTICS, "When condition of \"%s\" is accessing its own conditional node."
 
 #define LY_VCODE_INSTMT         LYVE_SYNTAX_YANG, "Invalid keyword \"%s\"."
 #define LY_VCODE_INCHILDSTMT    LYVE_SYNTAX_YANG, "Invalid keyword \"%s\" as a child of \"%s\"."
@@ -220,7 +221,6 @@
 #define LY_VCODE_XP_INARGCOUNT  LYVE_XPATH, "Invalid number of arguments (%d) for the XPath function %.*s."
 #define LY_VCODE_XP_INARGTYPE   LYVE_XPATH, "Wrong type of argument #%d (%s) for the XPath function %s."
 #define LY_VCODE_XP_INCTX       LYVE_XPATH, "Invalid context type %s in %s."
-#define LY_VCODE_XP_DUMMY       LYVE_XPATH, "Accessing the value of the dummy node \"%s\"."
 #define LY_VCODE_XP_INOP_1      LYVE_XPATH, "Cannot apply XPath operation %s on %s."
 #define LY_VCODE_XP_INOP_2      LYVE_XPATH, "Cannot apply XPath operation %s on %s and %s."
 #define LY_VCODE_XP_INMOD       LYVE_XPATH, "Unknown module \"%.*s\"."
diff --git a/src/tree_data.h b/src/tree_data.h
index 6820144..6e63d38 100644
--- a/src/tree_data.h
+++ b/src/tree_data.h
@@ -244,13 +244,13 @@
  *     ---------------------+-+-+-+-+-+-+-+
  *       1 LYD_DEFAULT      |x| |x|x| | | |
  *                          +-+-+-+-+-+-+-+
- *       2                  | | | | | | | |
+ *       2 LYD_WHEN_TRUE    |x|x|x|x|x| | |
  *     ---------------------+-+-+-+-+-+-+-+
  *
  */
 
-#define LYD_DEFAULT      0x01        /**< default (implicit) node; */
-#define LYD_DUMMY        0x80000000  /**< dummy node (in XPath context, internal flag) */
+#define LYD_DEFAULT      0x01        /**< default (implicit) node */
+#define LYD_WHEN_TRUE    0x02        /**< all when conditions of this node were evaluated to true */
 /** @} */
 
 /**
diff --git a/src/tree_schema_compile.c b/src/tree_schema_compile.c
index 574a49e..47e759f 100644
--- a/src/tree_schema_compile.c
+++ b/src/tree_schema_compile.c
@@ -4758,13 +4758,18 @@
 
                 if (!(ctx->options & LYSC_OPT_GROUPING)) {
                     /* do not check "when" semantics in a grouping */
-                    ly_set_add(&ctx->unres, target, 0);
+                    ly_set_add(&ctx->unres, node, 0);
                 }
 
                 when_shared = *when;
             } else {
                 ++when_shared->refcount;
                 (*when) = when_shared;
+
+                if (!(ctx->options & LYSC_OPT_GROUPING)) {
+                    /* in this case check "when" again for all children because of dummy node check */
+                    ly_set_add(&ctx->unres, node, 0);
+                }
             }
         }
     }
@@ -5040,6 +5045,11 @@
             } else {
                 ++when_shared->refcount;
                 (*when) = when_shared;
+
+                if (!(ctx->options & LYSC_OPT_GROUPING)) {
+                    /* in this case check "when" again for all children because of dummy node check */
+                    ly_set_add(&ctx->unres, child, 0);
+                }
             }
         }
     }
@@ -6940,7 +6950,7 @@
  * @return LY_ERR value
  */
 static LY_ERR
-lys_compile_check_cyclic_when(struct lyxp_set *set, const struct lysc_node *node)
+lys_compile_check_when_cyclic(struct lyxp_set *set, const struct lysc_node *node)
 {
     struct lyxp_set tmp_set;
     struct lyxp_set_scnode *xp_scnode;
@@ -6955,11 +6965,8 @@
     for (i = 0; i < set->used; ++i) {
         xp_scnode = &set->val.scnodes[i];
 
-        if ((xp_scnode->type == LYXP_NODE_ELEM) && (xp_scnode->scnode == node)) {
-            /* node when was already checked */
-            xp_scnode->in_ctx = 2;
-        } else {
-            /* check node when */
+        if (xp_scnode->in_ctx != -1) {
+            /* check node when, skip the context node (it was just checked) */
             xp_scnode->in_ctx = 1;
         }
     }
@@ -6993,7 +7000,7 @@
                     if (tmp_set.val.scnodes[j].type == LYXP_NODE_ELEM) {
                         /* try to find this node in our set */
                         idx = lyxp_set_scnode_dup_node_check(set, tmp_set.val.scnodes[j].scnode, LYXP_NODE_ELEM, -1);
-                        if ((idx > -1) && (set->val.scnodes[idx].in_ctx == 2)) {
+                        if ((idx > -1) && (set->val.scnodes[idx].in_ctx == -1)) {
                             LOGVAL(set->ctx, LY_VLOG_LYS, node, LY_VCODE_CIRC_WHEN, node->name, set->val.scnodes[idx].scnode->name);
                             ret = LY_EVALID;
                             goto cleanup;
@@ -7016,7 +7023,7 @@
         } while (node && (node->nodetype & (LYS_CASE | LYS_CHOICE)));
 
         /* this node when was checked */
-        xp_scnode->in_ctx = 2;
+        xp_scnode->in_ctx = -1;
     }
 
 cleanup:
@@ -7095,22 +7102,26 @@
         ctx->path[0] = '\0';
         lysc_path((struct lysc_node *)node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
         for (j = 0; j < tmp_set.used; ++j) {
-            /* skip roots'n'stuff, set in_ctx for when checking */
-            if (tmp_set.val.scnodes[j].type == LYXP_NODE_ELEM) {
+            /* skip roots'n'stuff */
+            if ((tmp_set.val.scnodes[j].type == LYXP_NODE_ELEM) && (tmp_set.val.scnodes[j].in_ctx != -1)) {
                 struct lysc_node *schema = tmp_set.val.scnodes[j].scnode;
 
                 /* XPath expression cannot reference "lower" status than the node that has the definition */
                 ret = lysc_check_status(ctx, when[i]->flags, when[i]->module, node->name, schema->flags, schema->module,
                                         schema->name);
                 LY_CHECK_GOTO(ret, cleanup);
+
+                /* check dummy node accessing */
+                if (schema == node) {
+                    LOGVAL(ctx->ctx, LY_VLOG_LYS, node, LY_VCODE_DUMMY_WHEN, node->name);
+                    ret = LY_EVALID;
+                    goto cleanup;
+                }
             }
         }
 
-        /* check dummy node accessing */
-        /* TODO */
-
         /* check cyclic dependencies */
-        ret = lys_compile_check_cyclic_when(&tmp_set, node);
+        ret = lys_compile_check_when_cyclic(&tmp_set, node);
         LY_CHECK_GOTO(ret, cleanup);
 
         lyxp_set_cast(&tmp_set, LYXP_SET_EMPTY);
diff --git a/src/xpath.c b/src/xpath.c
index 995941c..93dd7f6 100644
--- a/src/xpath.c
+++ b/src/xpath.c
@@ -502,11 +502,6 @@
 {
     int dynamic;
 
-    if ((set->val.nodes[0].type != LYXP_NODE_ATTR) && (set->val.nodes[0].node->flags & LYD_DUMMY)) {
-        LOGVAL(set->ctx, LY_VLOG_LYD, set->val.nodes[0].node, LY_VCODE_XP_DUMMY, set->val.nodes[0].node->schema->name);
-        return LY_EVALID;
-    }
-
     switch (set->val.nodes[0].type) {
     case LYXP_NODE_ROOT:
     case LYXP_NODE_ROOT_CONFIG:
@@ -924,6 +919,8 @@
     for (i = 0; i < set->used; ++i) {
         if (set->val.scnodes[i].in_ctx == 1) {
             set->val.scnodes[i].in_ctx = 0;
+        } else if (set->val.scnodes[i].in_ctx == -2) {
+            set->val.scnodes[i].in_ctx = -1;
         }
     }
 }
@@ -1223,10 +1220,11 @@
  * @param[in] set Set to modify.
  * @return New context value.
  */
-static uint32_t
+static int32_t
 set_scnode_new_in_ctx(struct lyxp_set *set)
 {
-    uint32_t ret_ctx, i;
+    uint32_t i;
+    int32_t ret_ctx;
 
     assert(set->type == LYXP_SET_SCNODE_SET);
 
@@ -4969,6 +4967,8 @@
         return LY_EVALID;
     }
 
+    set_init(&set_item, set);
+
     set_item.type = LYXP_SET_NODE_SET;
     set_item.val.nodes = malloc(sizeof *set_item.val.nodes);
     LY_CHECK_ERR_RET(!set_item.val.nodes, LOGMEM(set->ctx), LY_EMEM);
@@ -5022,10 +5022,6 @@
     for (i = 0; i < set->used;) {
         switch (set->val.nodes[i].type) {
         case LYXP_NODE_ELEM:
-            if (set->val.nodes[i].node->flags & LYD_DUMMY) {
-                LOGVAL(set->ctx, LY_VLOG_LYD, set->val.nodes[i].node, LY_VCODE_XP_DUMMY, set->val.nodes[i].node->schema->name);
-                return LY_EVALID;
-            }
             if (set->val.nodes[i].node->schema->nodetype & (LYS_LEAF | LYS_LEAFLIST)) {
                 set->val.nodes[i].type = LYXP_NODE_TEXT;
                 ++i;
@@ -5278,8 +5274,8 @@
         return LY_ENOT;
     }
 
-    /* dummy and context check */
-    if ((node->flags & LYD_DUMMY) || ((root_type == LYXP_NODE_ROOT_CONFIG) && (node->schema->flags & LYS_CONFIG_R))) {
+    /* context check */
+    if ((root_type == LYXP_NODE_ROOT_CONFIG) && (node->schema->flags & LYS_CONFIG_R)) {
         return LY_EINVAL;
     }
 
@@ -5389,9 +5385,8 @@
                 }
             }
 
-        /* skip nodes without children - leaves, leaflists, anyxmls, and dummy nodes (ouput root will eval to true) */
-        } else if (!(set->val.nodes[i].node->flags & LYD_DUMMY)
-                && !(set->val.nodes[i].node->schema->nodetype & (LYS_LEAF | LYS_LEAFLIST | LYS_ANYDATA))) {
+        /* skip nodes without children - leaves, leaflists, anyxmls (ouput root will eval to true) */
+        } else if (!(set->val.nodes[i].node->schema->nodetype & (LYS_LEAF | LYS_LEAFLIST | LYS_ANYDATA))) {
 
             for (sub = lyd_node_children(set->val.nodes[i].node); sub; sub = sub->next) {
                 rc = moveto_node_check(sub, set->root_type, name_dict, moveto_mod);
@@ -5464,9 +5459,13 @@
     orig_used = set->used;
     for (i = 0; i < orig_used; ++i) {
         if (set->val.scnodes[i].in_ctx != 1) {
-            continue;
+            if (set->val.scnodes[i].in_ctx != -2) {
+                continue;
+            }
+
+            /* remember context node */
+            set->val.scnodes[i].in_ctx = -1;
         }
-        set->val.scnodes[i].in_ctx = 0;
 
         start_parent = set->val.scnodes[i].scnode;
 
@@ -5657,9 +5656,13 @@
     orig_used = set->used;
     for (i = 0; i < orig_used; ++i) {
         if (set->val.scnodes[i].in_ctx != 1) {
-            continue;
+            if (set->val.scnodes[i].in_ctx != -2) {
+                continue;
+            }
+
+            /* remember context node */
+            set->val.scnodes[i].in_ctx = -1;
         }
-        set->val.scnodes[i].in_ctx = 0;
 
         /* TREE DFS */
         start = set->val.scnodes[i].scnode;
@@ -5757,7 +5760,7 @@
 
         /* only attributes of an elem (not dummy) can be in the result, skip all the rest;
          * our attributes are always qualified */
-        if ((set->val.nodes[i].type == LYXP_NODE_ELEM) && !(set->val.nodes[i].node->flags & LYD_DUMMY)) {
+        if (set->val.nodes[i].type == LYXP_NODE_ELEM) {
             for (sub = set->val.nodes[i].node->attr; sub; sub = sub->next) {
 
                 /* check "namespace" */
@@ -5950,7 +5953,7 @@
             set_insert_node(to_set, parent, 0, LYXP_NODE_ELEM, to_set->used);
 
             /* skip anydata/anyxml and dummy nodes */
-            if (!(parent->schema->nodetype & LYS_ANYDATA) && !(parent->flags & LYD_DUMMY)) {
+            if (!(parent->schema->nodetype & LYS_ANYDATA)) {
                 /* also add all the children of this node, recursively */
                 rc = moveto_self_add_children_r(parent, 0, LYXP_NODE_ELEM, to_set, dup_check_set, options);
                 LY_CHECK_RET(rc);
@@ -5974,8 +5977,8 @@
                 if (!set_dup_node_check(dup_check_set, sub, LYXP_NODE_ELEM, -1)) {
                     set_insert_node(to_set, sub, 0, LYXP_NODE_ELEM, to_set->used);
 
-                    /* skip anydata/anyxml and dummy nodes */
-                    if ((sub->schema->nodetype & LYS_ANYDATA) || (sub->flags & LYD_DUMMY)) {
+                    /* skip anydata/anyxml nodes */
+                    if (sub->schema->nodetype & LYS_ANYDATA) {
                         continue;
                     }
 
@@ -6040,8 +6043,8 @@
             continue;
         }
 
-        /* skip anydata/anyxml and dummy nodes */
-        if ((set->val.nodes[i].node->schema->nodetype & LYS_ANYDATA) || (set->val.nodes[i].node->flags & LYD_DUMMY)) {
+        /* skip anydata/anyxml nodes */
+        if (set->val.nodes[i].node->schema->nodetype & LYS_ANYDATA) {
             continue;
         }
 
@@ -6095,7 +6098,12 @@
     /* add all the children, they get added recursively */
     for (i = 0; i < set->used; ++i) {
         if (set->val.scnodes[i].in_ctx != 1) {
-            continue;
+            if (set->val.scnodes[i].in_ctx != -2) {
+                continue;
+            }
+
+            /* remember context node (it was traversed again so it changes to a normal node) */
+            set->val.scnodes[i].in_ctx = 1;
         }
 
         /* add all the children */
@@ -6239,9 +6247,13 @@
     orig_used = set->used;
     for (i = 0; i < orig_used; ++i) {
         if (set->val.scnodes[i].in_ctx != 1) {
-            continue;
+            if (set->val.scnodes[i].in_ctx != -2) {
+                continue;
+            }
+
+            /* remember context node */
+            set->val.scnodes[i].in_ctx = -1;
         }
-        set->val.scnodes[i].in_ctx = 0;
 
         node = set->val.scnodes[i].scnode;
 
@@ -6613,7 +6625,7 @@
 
             if ((rc == LY_SUCCESS) && set && (options & LYXP_SCNODE_ALL)) {
                 for (i = set->used - 1; i > -1; --i) {
-                    if (set->val.scnodes[i].in_ctx) {
+                    if (set->val.scnodes[i].in_ctx > 0) {
                         break;
                     }
                 }
@@ -6692,7 +6704,8 @@
 {
     LY_ERR rc;
     uint16_t i, orig_exp;
-    uint32_t orig_pos, orig_size, pred_in_ctx;
+    uint32_t orig_pos, orig_size;
+    int32_t pred_in_ctx;
     struct lyxp_set set2;
     struct lyd_node *orig_parent;
 
@@ -8307,6 +8320,7 @@
     memset(set, 0, sizeof *set);
     set->type = LYXP_SET_SCNODE_SET;
     lyxp_set_scnode_insert_node(set, ctx_scnode, ctx_scnode_type);
+    set->val.scnodes[0].in_ctx = -2;
     set->ctx = ctx;
     set->ctx_scnode = ctx_scnode;
     set->root_type = lyxp_get_root_type(NULL, ctx_scnode, options);
diff --git a/src/xpath.h b/src/xpath.h
index 1e27ab1..a0e45a1 100644
--- a/src/xpath.h
+++ b/src/xpath.h
@@ -214,11 +214,13 @@
         struct lyxp_set_scnode {
             struct lysc_node *scnode;
             enum lyxp_node_type type;
-            /* 0 - scnode was traversed, but not currently in the context,
-             * 1 - scnode currently in context,
-             * 2 - scnode in context and just added, so skip it for the current operation,
+            /* -2 - scnode not traversed, currently (the only node) in context;
+             * -1 - scnode not traversed except for the eval start, not currently in the context;
+             * 0  - scnode was traversed, but not currently in the context;
+             * 1  - scnode currently in context;
+             * 2  - scnode in context and just added, so skip it for the current operation;
              * >=3 - scnode is not in context because we are in a predicate and this scnode was used/will be used later */
-            uint32_t in_ctx;
+            int32_t in_ctx;
         } *scnodes;
         struct lyxp_set_attr {
             struct lyd_attr *attr;
diff --git a/tests/src/test_tree_schema_compile.c b/tests/src/test_tree_schema_compile.c
index de53e76..260e4dc 100644
--- a/tests/src/test_tree_schema_compile.c
+++ b/tests/src/test_tree_schema_compile.c
@@ -758,7 +758,7 @@
     assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, LY_CTX_DISABLE_SEARCHDIRS, &ctx));
 
     assert_non_null(mod = lys_parse_mem(ctx, "module a {namespace urn:a;prefix a;feature f;"
-                                        "choice ch {default a:b; when a2; case a {leaf a1 {type string;}leaf a2 {type string;}}"
+                                        "choice ch {default a:b; when \"true()\"; case a {leaf a1 {type string;}leaf a2 {type string;}}"
                                         "leaf b {type string;}}}", LYS_IN_YANG));
     ch = (struct lysc_node_choice*)mod->compiled->data;
     assert_non_null(ch);
@@ -3491,6 +3491,49 @@
     , LYS_IN_YANG));
     logbuf_assert("When condition of \"cont2\" includes a self-reference (referenced by when of \"val\").");
 
+    assert_null(lys_parse_mem(ctx,
+        "module a {"
+            "namespace urn:a;"
+            "prefix a;"
+            "leaf val {"
+                "type int64;"
+                "when \"../val='25'\";"
+            "}"
+        "}"
+    , LYS_IN_YANG));
+    logbuf_assert("When condition of \"val\" is accessing its own conditional node.");
+
+    assert_null(lys_parse_mem(ctx,
+        "module a {"
+            "namespace urn:a;"
+            "prefix a;"
+            "grouping grp {"
+                "leaf val {"
+                    "type int64;"
+                "}"
+            "}"
+            "uses grp {"
+                "when \"val='25'\";"
+            "}"
+        "}"
+    , LYS_IN_YANG));
+    logbuf_assert("When condition of \"val\" is accessing its own conditional node.");
+
+    assert_null(lys_parse_mem(ctx,
+        "module a {"
+            "namespace urn:a;"
+            "prefix a;"
+            "augment /cont {"
+                "when \"val='25'\";"
+                "leaf val {"
+                    "type int64;"
+                "}"
+            "}"
+            "container cont;"
+        "}"
+    , LYS_IN_YANG));
+    logbuf_assert("When condition of \"val\" is accessing its own conditional node.");
+
     *state = NULL;
     ly_ctx_destroy(ctx, NULL);
 }