else -> { error("Unhandled language result type: ${current.javaClass.simpleName}") }
        }
    }
    return buildString { recurse(languageResult, startDepth) }
}


fun prettyPrintLanguageTree(languageTreeElement: LanguageTreeElement): String {
    fun StringBuilder.recurse(current: LanguageTreeElement, depth: Int) {
        fun indent() = "    ".repeat(depth)
        fun nextIndent() = "    ".repeat(depth + 1)

            def found = [] as List<Operation>
            def recurse
            recurse = { List<Operation> children ->
                children.each { child ->
                    if (filter.isSatisfiedBy(child)) {
                        found << child
                    }
                    recurse child.children
                }
            }
            recurse children
            found
        }

// with the scope elements sorted by name.
// The level of indentation is controlled by n >= 0, with
// n == 0 for no indentation.
// If recurse is set, it also writes nested (children) scopes.
func (s *Scope) WriteTo(w io.Writer, n int, recurse bool) {
	const ind = ".  "
	indn := strings.Repeat(ind, n)

	fmt.Fprintf(w, "%s%s scope %p {\n", indn, s.comment, s)

	indn1 := indn + ind

// with the scope elements sorted by name.
// The level of indentation is controlled by n >= 0, with
// n == 0 for no indentation.
// If recurse is set, it also writes nested (children) scopes.
func (s *Scope) WriteTo(w io.Writer, n int, recurse bool) {
	const ind = ".  "
	indn := strings.Repeat(ind, n)

	fmt.Fprintf(w, "%s%s scope %p {\n", indn, s.comment, s)

	indn1 := indn + ind

        fun recurse(e: Expr): StringBuilder? = when (e) {
            is PropertyAccess -> {
                when (e.receiver) {
                    null -> StringBuilder(e.name)
                    else -> recurse(e.receiver)?.apply { append(".${e.name}") }
                }
            }

            else -> null
        }
        return recurse(this)?.toString()
    }
}

			return []string{"UNMATCHED"}
		}
	case *matcher.Matcher_OnMatch_Matcher:
		ms, f := recurse(fc.GetName(), v.Matcher)
		if !f {
			return []string{"NONE"}
		}
		return ms
	}
	ms, f := recurse(fc.GetName(), l.GetFilterChainMatcher())
	if !f {
		return []string{"NONE"}
	}
	return ms
}

func recurse(name string, match *matcher.Matcher) ([]string, bool) {

    }

    def "returns empty analysis"() {
        def a = analysis([:])
        expect: a.findTransitiveDependents(["Foo"], [:]).getAllDependentClasses().isEmpty()
    }

    def "does not recurse private dependencies"() {
        def a = analysis([
            "a": dependentSet(false, ["b"], []),
            "b": dependentSet(false, ["c"], ["d"]),
            "c": dependentSet(false, [], []),

            return result;
        }

        ManagedVersionMap versionMap = getManagedVersionsMap(originatingArtifact, managedVersions);

        try {
            recurse(
                    result,
                    root,
                    resolvedArtifacts,
                    versionMap,
                    repositoryRequest,
                    source,

			// It's a prefix for the field. Break and recurse
			// since it's not ok for one field path to be itself
			// the prefix for another field path.
			recurse = true

			// We can reuse the same slice as long as we
			// don't try to append to it.
			parents = finfo.parents[:len(parents)+1]
			break
		}
	}
	if !recurse {
		// We have no business with this element.
		return false, nil

  public final void test() {
    try {
      recurse(0);
    } catch (Exception e) { // sneaky checked exception
      throw new RuntimeException(Arrays.toString(stimuli), e);
    }
  }

  private void recurse(int level) {
    // We're going to reuse the stimuli array 3^steps times by overwriting it
    // in a recursive loop.  Sneaky.
    if (level == stimuli.length) {