unit
	toff  Offset // Offset to signature type within data.
	name  string // Name of .debug_type section.
	cache Type   // Cache the type, nil to start.
}

// Parse a .debug_types section.
func (d *Data) parseTypes(name string, types []byte) error {
	b := makeBuf(d, unknownFormat{}, name, 0, types)
	for len(b.data) > 0 {
		base := b.off
		n, dwarf64 := b.unitLength()
		if n != Offset(uint32(n)) {

// .debug_types sections. The name is used for error reporting only,
// and serves to distinguish one .debug_types section from another.
func (d *Data) AddTypes(name string, types []byte) error {
	return d.parseTypes(name, types)
}

// AddSection adds another DWARF section by name. The name should be a
// DWARF section name such as ".debug_addr", ".debug_str_offsets", and

		p.getPkg(pkgpath, pkgname)
		p.expectEOL()

	case "types":
		p.next()
		p.parseTypes(p.pkg)
		p.expectEOL()

	case "func":
		p.next()
		fun := p.parseFunc(p.pkg)
		if fun != nil {
			p.pkg.Scope().Insert(fun)
		}
		p.expectEOL()

	case "type":
		p.next()
		p.parseType(p.pkg)
		p.expectEOL()

	case "var":
		p.next()
		v := p.parseVar(p.pkg)

        private DecoratingConverter() {
            super(PublishArtifact.class);
        }

        @Override
        protected ConfigurablePublishArtifact parseType(PublishArtifact notation) {
            return instantiator.newInstance(DecoratingPublishArtifact.class, taskDependencyFactory, notation);
        }
    }

            visitor.candidate("Version catalog type-safe accessors.");
        }

        @Override
        protected ModuleVersionSelector parseType(ProviderConvertible<?> notation) {
            return providerConverter.parseType(notation.asProvider());
        }

    }

    static class ProviderConverter extends TypedNotationConverter<Provider<?>, ModuleVersionSelector> {

        if (typeToken.isInstance(notation)) {
            result.converted(parseType(typeToken.cast(notation)));
        }
    }

    abstract protected T parseType(N notation);

    }

    class DummyConverter extends TypedNotationConverter<String, Integer> {

        DummyConverter() {
            super(String.class)
        }

        Integer parseType(String notation) {
            return Integer.parseInt(notation);
        }
    }

        private LibraryConverter() {
            super(NativeLibrarySpec.class);
        }

        @Override
        protected NativeLibraryRequirement parseType(NativeLibrarySpec notation) {
            return notation.getShared();
        }
    }

    private static class NativeLibraryRequirementMapNotationConverter extends MapNotationConverter<NativeLibraryRequirement> {

namespace compiler {

class MlrtDialect : public mlir::Dialect {
 public:
  explicit MlrtDialect(mlir::MLIRContext *context);
  static llvm::StringRef getDialectNamespace() { return "mlrt"; }

  mlir::Type parseType(mlir::DialectAsmParser &parser) const override;
  void printType(mlir::Type type, mlir::DialectAsmPrinter &os) const override;
};

// The MLIR type represents a C++ mlrt::Future.
class FutureType

        private ArchiveTaskNotationConverter() {
            super(AbstractArchiveTask.class);
        }

        @Override
        protected IvyArtifact parseType(AbstractArchiveTask archiveTask) {
            return instantiator.newInstance(ArchiveTaskBasedIvyArtifact.class, archiveTask, publicationCoordinates, taskDependencyFactory);
        }
    }