private void processTypeAnnotations(
      AbstractClassTypeDeclarationDescr typeDescr, TypeDeclaration type) {
    try {
      Role role = typeDescr.getTypedAnnotation(Role.class);
      if (role != null) {
        type.setRole(role.value());
      }

      TypeSafe typeSafe = typeDescr.getTypedAnnotation(TypeSafe.class);
      if (typeSafe != null) {
        type.setTypesafe(typeSafe.value());
      }

      if (typeDescr instanceof EnumDeclarationDescr) {
        type.setKind(TypeDeclaration.Kind.ENUM);
      } else if (typeDescr instanceof TypeDeclarationDescr
          && ((TypeDeclarationDescr) typeDescr).isTrait()) {
        type.setKind(TypeDeclaration.Kind.TRAIT);
      }

      type.setDynamic(typeDescr.hasAnnotation(PropertyChangeSupport.class));
    } catch (Exception e) {
      kbuilder.addBuilderResult(new TypeDeclarationError(typeDescr, e.getMessage()));
    }
  }
 protected void setResourcesInDescriptors(Collection<? extends PackageDescr> packageDescrs) {
   for (PackageDescr packageDescr : packageDescrs) {
     for (AbstractClassTypeDeclarationDescr typeDescr :
         packageDescr.getClassAndEnumDeclarationDescrs()) {
       if (typeDescr.getResource() == null) {
         typeDescr.setResource(kbuilder.getCurrentResource());
       }
     }
   }
 }
 private Collection<AbstractClassTypeDeclarationDescr> compactDefinitionsAndDeclarations(
     Collection<AbstractClassTypeDeclarationDescr> unsortedDescrs,
     Map<String, AbstractClassTypeDeclarationDescr> unprocesseableDescrs) {
   Map<String, AbstractClassTypeDeclarationDescr> compactedUnsorted =
       new HashMap<String, AbstractClassTypeDeclarationDescr>(unsortedDescrs.size());
   for (AbstractClassTypeDeclarationDescr descr : unsortedDescrs) {
     if (compactedUnsorted.containsKey(descr.getType().getFullName())) {
       AbstractClassTypeDeclarationDescr prev =
           compactedUnsorted.get(descr.getType().getFullName());
       boolean res = mergeTypeDescriptors(prev, descr);
       if (!res) {
         unprocesseableDescrs.put(prev.getType().getFullName(), prev);
         kbuilder.addBuilderResult(
             new TypeDeclarationError(
                 prev,
                 "Found duplicate declaration for type "
                     + prev.getType().getFullName()
                     + ", unable to reconcile "));
       }
     } else {
       compactedUnsorted.put(descr.getType().getFullName(), descr);
     }
   }
   return compactedUnsorted.values();
 }
  public TypeDeclaration processTypeDeclaration(
      PackageRegistry pkgRegistry, AbstractClassTypeDeclarationDescr typeDescr) {

    TypeDeclaration type =
        kbuilder.getTypeBuilder().getExistingTypeDeclaration(typeDescr.getFullTypeName());
    if (type == null) {
      type = new TypeDeclaration(typeDescr.getTypeName());
      type.setResource(typeDescr.getResource());

      // if is not new, search the already existing declaration and
      // compare them o see if they are at least compatibles
      // check whether it is necessary to build the class or not
      type.setNovel(TypeDeclarationUtils.isNovelClass(typeDescr, pkgRegistry));
      type.setNature(
          type.isNovel() ? TypeDeclaration.Nature.DEFINITION : TypeDeclaration.Nature.DECLARATION);
    }

    processTypeAnnotations(typeDescr, type);
    return type;
  }
 private TypeDeclarationError reportDeclarationDiff(
     ClassFieldInspector cfi, AbstractClassTypeDeclarationDescr typeDescr) {
   List<String> existing = new ArrayList<String>();
   for (String existingFieldName : cfi.getFieldTypesField().keySet()) {
     if (!cfi.isNonGetter(existingFieldName)
         && !"class".equals(existingFieldName)
         && cfi.getSetterMethods().containsKey(existingFieldName)) {
       existing.add(existingFieldName);
     }
   }
   Collections.sort(existing);
   List<String> declared = new ArrayList<String>(typeDescr.getFields().keySet());
   Collections.sort(declared);
   List<String> deltas = new ArrayList<String>();
   for (String s : existing) {
     if (!declared.contains(s)) {
       deltas.add("--" + s);
     }
   }
   for (String s : declared) {
     if (!existing.contains(s)) {
       deltas.add("++" + s);
     }
   }
   return new TypeDeclarationError(
       typeDescr,
       "New declaration of "
           + typeDescr.getType().getFullName()
           + " can't declare a different set of fields \n"
           + "existing : "
           + existing
           + "\n"
           + "declared : "
           + declared
           + "\n"
           + "diff : "
           + deltas);
 }
  protected void normalizeForeignPackages(PackageDescr packageDescr) {
    Map<String, PackageDescr> foreignPackages = null;

    for (AbstractClassTypeDeclarationDescr typeDescr :
        packageDescr.getClassAndEnumDeclarationDescrs()) {
      if (kbuilder.filterAccepts(
          ResourceChange.Type.DECLARATION, typeDescr.getNamespace(), typeDescr.getTypeName())) {

        if (!typeDescr.getNamespace().equals(packageDescr.getNamespace())) {
          // If the type declaration is for a different namespace, process that separately.
          PackageDescr altDescr;

          if (foreignPackages == null) {
            foreignPackages = new HashMap<String, PackageDescr>();
          }

          if (foreignPackages.containsKey(typeDescr.getNamespace())) {
            altDescr = foreignPackages.get(typeDescr.getNamespace());
          } else {
            altDescr = new PackageDescr(typeDescr.getNamespace());
            altDescr.setResource(packageDescr.getResource());
            foreignPackages.put(typeDescr.getNamespace(), altDescr);
          }

          if (typeDescr instanceof TypeDeclarationDescr) {
            altDescr.addTypeDeclaration((TypeDeclarationDescr) typeDescr);
          } else if (typeDescr instanceof EnumDeclarationDescr) {
            altDescr.addEnumDeclaration((EnumDeclarationDescr) typeDescr);
          }

          for (ImportDescr imp : packageDescr.getImports()) {
            altDescr.addImport(imp);
          }
          if (!kbuilder.getPackageRegistry().containsKey(altDescr.getNamespace())) {
            kbuilder.createPackageRegistry(altDescr);
          }
        }
      }
    }
  }
  /**
   * ********************************************************************************************************************************************************************
   * 1) Process the TypeDeclaration Descriptors Resolve names Normalize field descriptors
   * ********************************************************************************************************************************************************************
   */
  public void processTypeDeclarations(
      Collection<? extends PackageDescr> packageDescrs,
      Collection<AbstractClassTypeDeclarationDescr> unsortedDescrs,
      List<TypeDefinition> unresolvedTypes,
      Map<String, AbstractClassTypeDeclarationDescr> unprocesseableDescrs) {

    // init package to ensure type resolvers are available
    for (PackageDescr packageDescr : packageDescrs) {
      if (kbuilder.getPackageRegistry(packageDescr.getName()) == null) {
        kbuilder.createPackageRegistry(packageDescr);
      }
    }

    setResourcesInDescriptors(packageDescrs);

    // ensure all names are fully qualified before continuing
    typeDeclarationNameResolver.resolveTypes(packageDescrs, unresolvedTypes);

    // create "implicit" packages
    for (PackageDescr packageDescr : packageDescrs) {
      normalizeForeignPackages(packageDescr);
    }

    // merge "duplicate" definitions and declarations
    unsortedDescrs = compactDefinitionsAndDeclarations(unsortedDescrs, unprocesseableDescrs);

    // now sort declarations by mutual dependencies
    ClassHierarchyManager classHierarchyManager =
        new ClassHierarchyManager(unsortedDescrs, kbuilder);

    for (AbstractClassTypeDeclarationDescr typeDescr :
        classHierarchyManager.getSortedDescriptors()) {
      PackageRegistry pkgRegistry = kbuilder.getPackageRegistry(typeDescr.getNamespace());
      createBean(
          typeDescr, pkgRegistry, classHierarchyManager, unresolvedTypes, unprocesseableDescrs);
    }

    for (AbstractClassTypeDeclarationDescr typeDescr :
        classHierarchyManager.getSortedDescriptors()) {
      if (!unprocesseableDescrs.containsKey(typeDescr.getType().getFullName())) {
        PackageRegistry pkgRegistry = kbuilder.getPackageRegistry(typeDescr.getNamespace());
        typeDeclarationConfigurator.wireFieldAccessors(
            pkgRegistry,
            typeDescr,
            pkgRegistry.getPackage().getTypeDeclaration(typeDescr.getType().getName()));
      }
    }
  }
 void registerGeneratedType(AbstractClassTypeDeclarationDescr typeDescr) {
   String fullName = typeDescr.getType().getFullName();
   generatedTypes.add(fullName);
 }
  protected void updateTraitInformation(
      AbstractClassTypeDeclarationDescr typeDescr,
      TypeDeclaration type,
      ClassDefinition def,
      PackageRegistry pkgRegistry) {
    if (typeDescr.hasAnnotation(Traitable.class)
        || (!type.getKind().equals(TypeDeclaration.Kind.TRAIT)
            && kbuilder.getPackageRegistry().containsKey(def.getSuperClass())
            && kbuilder
                .getPackageRegistry(def.getSuperClass())
                .getTraitRegistry()
                .getTraitables()
                .containsKey(def.getSuperClass()))) {
      // traitable
      if (type.isNovel()) {
        try {
          PackageRegistry reg = kbuilder.getPackageRegistry(typeDescr.getNamespace());
          String availableName = typeDescr.getType().getFullName();
          Class<?> resolvedType = reg.getTypeResolver().resolveType(availableName);
          updateTraitDefinition(type, resolvedType, false);
        } catch (ClassNotFoundException cnfe) {
          // we already know the class exists
        }
      }
      pkgRegistry.getTraitRegistry().addTraitable(def);
    } else if (type.getKind().equals(TypeDeclaration.Kind.TRAIT)
        || typeDescr.hasAnnotation(Trait.class)) {
      // trait
      if (!type.isNovel()) {
        try {
          PackageRegistry reg = kbuilder.getPackageRegistry(typeDescr.getNamespace());
          String availableName = typeDescr.getType().getFullName();
          Class<?> resolvedType = reg.getTypeResolver().resolveType(availableName);
          if (!Thing.class.isAssignableFrom(resolvedType)) {
            if (!resolvedType.isInterface()) {
              kbuilder.addBuilderResult(
                  new TypeDeclarationError(
                      typeDescr,
                      "Unable to redeclare concrete class "
                          + resolvedType.getName()
                          + " as a trait."));
              return;
            }
            updateTraitDefinition(type, resolvedType, false);

            String target = typeDescr.getTypeName() + TraitFactory.SUFFIX;
            TypeDeclarationDescr tempDescr = new TypeDeclarationDescr();
            tempDescr.setNamespace(typeDescr.getNamespace());
            tempDescr.setFields(typeDescr.getFields());
            tempDescr.setType(target, typeDescr.getNamespace());
            tempDescr.setTrait(true);
            tempDescr.addSuperType(typeDescr.getType());
            tempDescr.setResource(type.getResource());
            TypeDeclaration tempDeclr = new TypeDeclaration(target);
            tempDeclr.setKind(TypeDeclaration.Kind.TRAIT);
            tempDeclr.setTypesafe(type.isTypesafe());
            tempDeclr.setNovel(true);
            tempDeclr.setTypeClassName(tempDescr.getType().getFullName());
            tempDeclr.setResource(type.getResource());

            ClassDefinition tempDef = new ClassDefinition(target);
            tempDef.setClassName(tempDescr.getType().getFullName());
            tempDef.setTraitable(false);
            for (FieldDefinition fld : def.getFieldsDefinitions()) {
              tempDef.addField(fld);
            }
            tempDef.setInterfaces(def.getInterfaces());
            tempDef.setSuperClass(def.getClassName());
            tempDef.setDefinedClass(resolvedType);
            tempDef.setAbstrakt(true);
            tempDeclr.setTypeClassDef(tempDef);

            declaredClassBuilder.generateBeanFromDefinition(
                tempDescr, tempDeclr, pkgRegistry, tempDef);
            try {
              Class<?> clazz =
                  pkgRegistry.getTypeResolver().resolveType(tempDescr.getType().getFullName());
              tempDeclr.setTypeClass(clazz);

              pkgRegistry
                  .getTraitRegistry()
                  .addTrait(tempDef.getClassName().replace(TraitFactory.SUFFIX, ""), tempDef);

            } catch (ClassNotFoundException cnfe) {
              kbuilder.addBuilderResult(
                  new TypeDeclarationError(
                      typeDescr,
                      "Internal Trait extension Class '"
                          + target
                          + "' could not be generated correctly'"));
            } finally {
              pkgRegistry.getPackage().addTypeDeclaration(tempDeclr);
            }

          } else {
            updateTraitDefinition(type, resolvedType, true);
            pkgRegistry.getTraitRegistry().addTrait(def);
          }
        } catch (ClassNotFoundException cnfe) {
          // we already know the class exists
        }
      } else {
        if (def.getClassName().endsWith(TraitFactory.SUFFIX)) {
          pkgRegistry
              .getTraitRegistry()
              .addTrait(def.getClassName().replace(TraitFactory.SUFFIX, ""), def);
        } else {
          pkgRegistry.getTraitRegistry().addTrait(def);
        }
      }
    }
  }
  protected void createBean(
      AbstractClassTypeDeclarationDescr typeDescr,
      PackageRegistry pkgRegistry,
      ClassHierarchyManager hierarchyManager,
      List<TypeDefinition> unresolvedTypes,
      Map<String, AbstractClassTypeDeclarationDescr> unprocesseableDescrs) {

    // descriptor needs fields inherited from superclass
    if (typeDescr instanceof TypeDeclarationDescr) {
      hierarchyManager.inheritFields(
          pkgRegistry,
          typeDescr,
          hierarchyManager.getSortedDescriptors(),
          unresolvedTypes,
          unprocesseableDescrs);
    }

    TypeDeclaration type = typeDeclarationFactory.processTypeDeclaration(pkgRegistry, typeDescr);
    boolean success = !kbuilder.hasErrors();

    try {
      // the type declaration is generated in any case (to be used by subclasses, if any)
      // the actual class will be generated only if needed
      ClassDefinition def = null;
      if (success) {
        def =
            classDefinitionFactory.generateDeclaredBean(
                typeDescr, type, pkgRegistry, unresolvedTypes, unprocesseableDescrs);

        // now use the definition to compare redeclarations, if any
        // this has to be done after the classDef has been generated
        if (!type.isNovel()) {
          typeDeclarationFactory.checkRedeclaration(typeDescr, type, pkgRegistry);
        }
      }
      success = (def != null) && (!kbuilder.hasErrors());

      if (success) {
        updateTraitInformation(typeDescr, type, def, pkgRegistry);
      }
      success = !kbuilder.hasErrors();

      if (success) {
        declaredClassBuilder.generateBeanFromDefinition(typeDescr, type, pkgRegistry, def);
      }
      success = !kbuilder.hasErrors();

      if (success) {
        Class<?> clazz =
            pkgRegistry.getTypeResolver().resolveType(typeDescr.getType().getFullName());
        type.setTypeClass(clazz);
        type.setValid(true);
      } else {
        unprocesseableDescrs.put(typeDescr.getType().getFullName(), typeDescr);
        type.setValid(false);
      }

      typeDeclarationConfigurator.finalize(
          type, typeDescr, pkgRegistry, kbuilder.getPackageRegistry(), hierarchyManager);

    } catch (final ClassNotFoundException e) {
      unprocesseableDescrs.put(typeDescr.getType().getFullName(), typeDescr);
      kbuilder.addBuilderResult(
          new TypeDeclarationError(
              typeDescr,
              "Class '"
                  + type.getTypeClassName()
                  + "' not found for type declaration of '"
                  + type.getTypeName()
                  + "'"));
    }

    if (!success) {
      unresolvedTypes.add(new TypeDefinition(type, typeDescr));
    } else {
      registerGeneratedType(typeDescr);
    }
  }
 private boolean isDefinition(AbstractClassTypeDeclarationDescr prev) {
   return !prev.getFields().isEmpty();
 }
  private boolean mergeTypeDescriptors(
      AbstractClassTypeDeclarationDescr prev, AbstractClassTypeDeclarationDescr descr) {
    boolean isDef1 = isDefinition(prev);
    boolean isDef2 = isDefinition(descr);

    if (isDef1 && isDef2) {
      return false;
    }
    if (!prev.getSuperTypes().isEmpty()
        && !descr.getSuperTypes().isEmpty()
        && prev.getSuperTypes().size() != descr.getSuperTypes().size()) {
      return false;
    }

    if (prev.getSuperTypes().isEmpty()) {
      for (QualifiedName qn : descr.getSuperTypes()) {
        ((TypeDeclarationDescr) prev).addSuperType(qn);
      }
    }
    if (prev.getFields().isEmpty()) {
      for (String fieldName : descr.getFields().keySet()) {
        prev.addField(descr.getFields().get(fieldName));
      }
    }
    for (AnnotationDescr ad : descr.getAnnotations()) {
      prev.addQualifiedAnnotation(ad);
    }
    for (AnnotationDescr ad : prev.getAnnotations()) {
      if (!descr.getAnnotations().contains(ad)) {
        descr.addQualifiedAnnotation(ad);
      }
    }
    return true;
  }
  protected void checkRedeclaration(
      AbstractClassTypeDeclarationDescr typeDescr,
      TypeDeclaration type,
      PackageRegistry pkgRegistry) {
    TypeDeclaration previousTypeDeclaration =
        kbuilder
            .getPackageRegistry(typeDescr.getNamespace())
            .getPackage()
            .getTypeDeclaration(typeDescr.getTypeName());

    try {
      // if there is no previous declaration, then the original declaration was a POJO
      // to the behavior previous these changes
      if (previousTypeDeclaration == null) {
        // new declarations of a POJO can't declare new fields,
        // except if the POJO was previously generated/compiled and saved into the kjar
        Class<?> existingDeclarationClass =
            TypeDeclarationUtils.getExistingDeclarationClass(typeDescr, pkgRegistry);
        if (!kbuilder.getBuilderConfiguration().isPreCompiled()
            && !GeneratedFact.class.isAssignableFrom(existingDeclarationClass)
            && !type.getTypeClassDef().getFields().isEmpty()) {
          try {
            Class existingClass =
                pkgRegistry
                    .getPackage()
                    .getTypeResolver()
                    .resolveType(typeDescr.getType().getFullName());
            ClassFieldInspector cfi = new ClassFieldInspector(existingClass);

            int fieldCount = 0;
            for (String existingFieldName : cfi.getFieldTypesField().keySet()) {
              if (!cfi.isNonGetter(existingFieldName)
                  && !"class".equals(existingFieldName)
                  && cfi.getSetterMethods().containsKey(existingFieldName)
                  && cfi.getGetterMethods().containsKey(existingFieldName)) {
                if (!typeDescr.getFields().containsKey(existingFieldName)) {
                  type.setValid(false);
                  kbuilder.addBuilderResult(
                      new TypeDeclarationError(
                          typeDescr,
                          "New declaration of "
                              + typeDescr.getType().getFullName()
                              + " does not include field "
                              + existingFieldName));
                } else {
                  String fldType = cfi.getFieldTypes().get(existingFieldName).getName();
                  fldType =
                      TypeDeclarationUtils.toBuildableType(fldType, kbuilder.getRootClassLoader());
                  TypeFieldDescr declaredField = typeDescr.getFields().get(existingFieldName);
                  if (!fldType.equals(
                      type.getTypeClassDef().getField(existingFieldName).getTypeName())) {
                    type.setValid(false);
                    kbuilder.addBuilderResult(
                        new TypeDeclarationError(
                            typeDescr,
                            "New declaration of "
                                + typeDescr.getType().getFullName()
                                + " redeclared field "
                                + existingFieldName
                                + " : \n"
                                + "existing : "
                                + fldType
                                + " vs declared : "
                                + declaredField.getPattern().getObjectType()));
                  } else {
                    fieldCount++;
                  }
                }
              }
            }

            if (fieldCount != typeDescr.getFields().size()) {
              kbuilder.addBuilderResult(reportDeclarationDiff(cfi, typeDescr));
            }
          } catch (IOException e) {
            e.printStackTrace();
            type.setValid(false);
            kbuilder.addBuilderResult(
                new TypeDeclarationError(
                    typeDescr,
                    "Unable to redeclare "
                        + typeDescr.getType().getFullName()
                        + " : "
                        + e.getMessage()));
          } catch (ClassNotFoundException e) {
            type.setValid(false);
            kbuilder.addBuilderResult(
                new TypeDeclarationError(
                    typeDescr,
                    "Unable to redeclare "
                        + typeDescr.getType().getFullName()
                        + " : "
                        + e.getMessage()));
          }
        }
      } else {

        int typeComparisonResult = this.compareTypeDeclarations(previousTypeDeclaration, type);

        if (typeComparisonResult < 0) {
          // oldDeclaration is "less" than newDeclaration -> error
          kbuilder.addBuilderResult(
              new TypeDeclarationError(
                  typeDescr,
                  typeDescr.getType().getFullName()
                      + " declares more fields than the already existing version"));
          type.setValid(false);
        } else if (typeComparisonResult > 0 && !type.getTypeClassDef().getFields().isEmpty()) {
          // oldDeclaration is "grater" than newDeclaration -> error
          kbuilder.addBuilderResult(
              new TypeDeclarationError(
                  typeDescr,
                  typeDescr.getType().getFullName()
                      + " declares less fields than the already existing version"));
          type.setValid(false);
        }

        // if they are "equal" -> no problem

        // in the case of a declaration, we need to copy all the
        // fields present in the previous declaration
        if (type.getNature() == TypeDeclaration.Nature.DECLARATION) {
          mergeTypeDeclarations(previousTypeDeclaration, type);
        }
      }

    } catch (IncompatibleClassChangeError error) {
      // if the types are incompatible -> error
      kbuilder.addBuilderResult(new TypeDeclarationError(typeDescr, error.getMessage()));
    }
  }