}

    @Override
    public void visit(ClassOrInterfaceDeclaration classDeclaration, ClassMetaDataRepository<ClassMetaData> repository) {
        visitTypeDeclaration(classDeclaration, repository, classDeclaration.isInterface() ? MetaType.INTERFACE : MetaType.CLASS, () -> {
            visitExtendedTypes(classDeclaration);
            visitImplementedTypes(classDeclaration);
            super.visit(classDeclaration, repository);
        });

    }

    public String getSimpleName() {
        return StringUtils.substringAfterLast(className, ".");
    }

    public String getPackageName() {
        return packageName;
    }

    public boolean isInterface() {
        return metaType == MetaType.INTERFACE;
    }

    public boolean isGroovy() {
        return isGroovy;
    }

    public boolean isEnum() {
        return metaType == MetaType.ENUM;
    }

        }
    }

    /**
     * Prepares the fields.
     */
    protected void setupFieldDescs() {
        if (beanClass.isInterface()) {
            setupFieldDescsByInterface(beanClass);
        } else {
            setupFieldDescsByClass(beanClass);
        }
    }

    /**
     * Prepares the fields defined in the interface.

        logger.log(Level.SEVERE, "Cannot load class " + classInfo + ", skipping...", e);
        continue;
      }
      if (!cls.isInterface()) {
        classes.add(cls);
      }
    }
    return classes;
  }

  private static boolean hasTest(Class<?> testClass, Iterable<String> testNames) {
    for (String testName : testNames) {

            assertNotNull(resource.getLocator(), "Should have resource locator for SMB addressing");

            // Verify interface provides SMB-specific functionality
            assertTrue(SmbResource.class.isInterface(), "Should be an interface");
            assertTrue(AutoCloseable.class.isAssignableFrom(SmbResource.class), "Should be closeable for resource management");
        }

        @Test

        logger.log(Level.SEVERE, "Cannot load class " + classInfo + ", skipping...", e);
        continue;
      }
      if (!cls.isInterface()) {
        classes.add(cls);
      }
    }
    return classes;
  }

  private static boolean hasTest(Class<?> testClass, Iterable<String> testNames) {
    for (String testName : testNames) {

      @SuppressWarnings("unchecked") // returns default for both F and T
      T defaultConverter = (T) defaultConverter(convertFromType, convertToType);
      return defaultConverter;
    }
    if (type.getRawType().isInterface()) {
      return newDefaultReturningProxy(type);
    }
    return null;
  }

  private <F, T> Converter<F, T> defaultConverter(
      TypeToken<F> convertFromType, TypeToken<T> convertToType) {

      }
      return invokeGeneratorMethod(generate, args.toArray());
    }
    return defaultGenerate(rawType);
  }

  private <T> @Nullable T defaultGenerate(Class<T> rawType) {
    if (rawType.isInterface()) {
      // always create a new proxy
      return newProxy(rawType);
    }
    return ArbitraryInstances.get(rawType);
  }

  private <T> T newProxy(Class<T> interfaceType) {

pkg go/types, func ExprString(ast.Expr) string
pkg go/types, func Id(*Package, string) string
pkg go/types, func Identical(Type, Type) bool
pkg go/types, func Implements(Type, *Interface) bool
pkg go/types, func IsInterface(Type) bool
pkg go/types, func LookupFieldOrMethod(Type, bool, *Package, string) (Object, []int, bool)
pkg go/types, func MissingMethod(Type, *Interface, bool) (*Func, bool)
pkg go/types, func NewArray(Type, int64) *Array

      }
      try {
        NetworkInterface asInterface = NetworkInterface.getByName(scope);
        if (asInterface == null) {
          throw formatIllegalArgumentException("No such interface: '%s'", scope);
        }
        return Inet6Address.getByAddress(
            v6Address.getHostAddress(), v6Address.getAddress(), asInterface);
      } catch (SocketException | UnknownHostException e) {