@Nullable
		private ClassEntry computeEntry(@Nonnull ClassInfo info, int ttl) {
			ClassEntry entry = cache.get(info.getName());
			if (entry != null)
				return entry;

			// Decrement TTL and if it reaches 0 we abort.
			if (--ttl <= 0)
				return null;

			// Construct the class entry model.
			//   NOTE: Parent types are fully computed regardless of TTL. The TTL reduction is used further below.
			ClassEntry superClass = info.getSuperName() == null ? null : getClass(info.getSuperName());
			List<FieldEntry> fields = info.getFields().stream()
					.map(f -> (FieldEntry) new BasicFieldEntry(f.getName(), f.getDescriptor(), f.getAccess()))
					.toList();
			List<MethodEntry> methods = info.getMethods().stream()
					.map(m -> (MethodEntry) new BasicMethodEntry(m.getName(), m.getDescriptor(), m.getAccess()))
					.toList();
			List<ClassEntry> innerClasses = new ArrayList<>();
			List<ClassEntry> interfaces = new ArrayList<>();
			entry = new BasicClassEntry(info.getName(), info.getAccess(), superClass, interfaces, innerClasses, fields, methods);
			register(entry);

			// Lists of other classes are populated after we put the entry in the pool to prevent entry building cycles.
			for (InnerClassInfo innerClass : info.getInnerClasses()) {
				if (innerClass.isExternalReference())
					continue;
				ClassEntry innerClassEntry = getClass(innerClass.getInnerClassName());
				if (innerClassEntry != null)
					innerClasses.add(innerClassEntry);
			}
			for (String implemented : info.getInterfaces()) {
				ClassEntry interfaceEntry = getClass(implemented);
				if (interfaceEntry != null)
					interfaces.add(interfaceEntry);
			}

			// Ensure all referenced classes are populated in the pool.
			// Because we only branch out based off a decrementing TTL counter, we should only end up mapping a few levels outwards.
			// This ensures that when we do any resolving logic with this pool, associated classes are readily available in the pool.
			//
			// There is a concern that the edges which fall on TTL==1 won't have their contents "readily available"
			// but in practice when those missing items are loaded it kicks off another round of pre-emptive loading.
			// This should result in a UX that is largely smoother overall, especially if the user is interacting with
			// classes that are "nearby" each other in terms of inheritance or external references.
			if (info instanceof JvmClassInfo jvmClassInfo)
				for (String referencedClass : jvmClassInfo.getReferencedClasses())
					getClass(referencedClass, ttl);

			return entry;
		}
@param info
		Class model in the workspace to map to a form for context resolution.
@param ttl
		Time-to-live, which will prevent construction of new entries when it reaches 0.

@return Newly created entry modeling the given class.
recaf-core/src/main/java/software/coley/recaf/services/source/AstService.java