dependents.forEach(dependent -> addAccessibleDependent(constantOrigin, dependent));
        return this;
    }

    public ConstantToDependentsMappingBuilder addPrivateDependents(String constantOrigin, Collection<String> dependents) {
        dependents.forEach(dependent -> addPrivateDependent(constantOrigin, dependent));
        return this;
    }

        oldMapping.getConstantDependents().keySet().stream()
            .filter(constantOrigin -> !changedClasses.contains(constantOrigin))
            .forEach(constantOrigin -> {
                DependentsSet dependents = oldMapping.getConstantDependentsForClass(constantOrigin);
                Set<String> accessibleDependents = new HashSet<>(dependents.getAccessibleDependentClasses());

     * class A {
     *     public static final int CALCULATE_ACCESSIBLE_CONSTANT = CONSTANT;
     * }
     */
    public void consumeAccessibleDependent(String constantOrigin, String constantDependent) {
        accessibleDependentDelegate.accept(constantOrigin, constantDependent);
    }

    /**
     * Consume "private" dependents of a constant.
     *
     * Example of private constant dependent:
     * class A {

    }

    public void addPublicDependent(String constantOrigin, String constantDependent) {
        if (!constantOrigin.equals(constantDependent)) {
            constantToDependentsMappingBuilder.addAccessibleDependent(constantOrigin, constantDependent);
        }
    }

    public void addPrivateDependent(String constantOrigin, String constantDependent) {
        if (!constantOrigin.equals(constantDependent)) {

        this.consumer = consumer;
    }

    public String getVisitedClass() {
        return visitedClass;
    }

    public void addConstantOrigin(String constantOrigin) {
        if (!constantOrigin.equals(visitedClass)) {
            consumer.accept(constantOrigin, visitedClass);
        }
    }

    }

    public Map<String, DependentsSet> getConstantDependents() {
        return constantDependents;
    }

    public DependentsSet getConstantDependentsForClass(String constantOrigin) {
        return constantDependents.getOrDefault(constantOrigin, DependentsSet.empty());
    }

    public static ConstantToDependentsMapping empty() {
        return new ConstantToDependentsMapping(Collections.emptyMap());
    }

        this.constantToDependentsMapping = constantToDependentsMapping;
    }

    public DependentsSet getConstantDependentsForClass(String constantOrigin) {
        return constantToDependentsMapping.getConstantDependentsForClass(constantOrigin);
    }

    public ConstantToDependentsMapping getConstantToClassMapping() {
        return constantToDependentsMapping;
    }

    public boolean isAvailable() {

            is This -> currentScopes.last().receiver
        }
    }

    private
    fun <T : Any> literalObjectOrigin(literalExpr: Literal<T>): ObjectOrigin =
        ObjectOrigin.ConstantOrigin(literalExpr)

        val lambdaAccessedObjects: List<ObjectReflection>
    ) : ObjectReflection

    data class ConstantValue(
        override val type: DataType.ConstantType<*>,
        override val objectOrigin: ObjectOrigin.ConstantOrigin,
        val value: Any
    ) : ObjectReflection

    data class External(
        override val type: DataType,
        override val objectOrigin: ObjectOrigin.External,
    ) : ObjectReflection {

            val value = resolvedAssignments[strAssignment.lhs]
            assertIs<AssignmentResolver.AssignmentResolutionResult.Assigned>(value)
            val valueOrigin = value.objectOrigin
            assertIs<ObjectOrigin.ConstantOrigin>(valueOrigin)
            assertEquals("shared", valueOrigin.literal.value)
        }
    }

    @Test
    fun `reports assignment pointing to unassigned property`() {
        assignmentTrace(