plugins/InspectionGadgets/src/com/siyeh/ig/fixes/SerialVersionUIDBuilder.java

   1 /*
   2  * Copyright 2003-2006 Bas Leijdekkers
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package com.siyeh.ig.fixes;
  17
  18 import com.intellij.openapi.project.Project;
  19 import com.intellij.psi.*;
  20 import com.intellij.psi.search.GlobalSearchScope;
  21 import com.intellij.psi.tree.IElementType;
  22 import com.intellij.psi.util.PsiFormatUtil;
  23 import com.intellij.psi.util.PsiUtil;
  24 import com.siyeh.ig.psiutils.ClassUtils;
  25 import org.jetbrains.annotations.NonNls;
  26 import org.jetbrains.annotations.NotNull;
  27
  28 import java.io.ByteArrayOutputStream;
  29 import java.io.DataOutputStream;
  30 import java.io.IOException;
  31 import java.lang.reflect.Modifier;
  32 import java.security.MessageDigest;
  33 import java.security.NoSuchAlgorithmException;
  34 import java.util.*;
  35
  36 public class SerialVersionUIDBuilder extends JavaRecursiveElementVisitor{
  37
  38     @NonNls private static final String ACCESS_METHOD_NAME_PREFIX = "access$";
  39
  40     private static final String SERIALIZABLE_CLASS_NAME = "java.io.Serializable";
  41
  42     private PsiClass clazz;
  43     private int index = -1;
  44     private Set<MemberSignature> nonPrivateConstructors;
  45     private Set<MemberSignature> nonPrivateMethods;
  46     private Set<MemberSignature> nonPrivateFields;
  47     private List<MemberSignature> staticInitializers;
  48     private boolean assertStatement = false;
  49     private boolean classObjectAccessExpression = false;
  50     private Map<PsiElement, String> memberMap =
  51             new HashMap<PsiElement, String>();
  52
  53     private static final Comparator<PsiClass> INTERFACE_COMPARATOR =
  54             new Comparator<PsiClass>(){
  55         public int compare(PsiClass object1, PsiClass object2){
  56             if(object1 == null && object2 == null)
  57             {
  58                 return 0;
  59             }if(object1 == null)
  60             {
  61                 return 1;
  62             }
  63             if(object2 == null)
  64             {
  65                 return -1;
  66             }
  67             final String name1 = object1.getQualifiedName();
  68             final String name2 = object2.getQualifiedName();
  69             if(name1 == null && name2 == null){
  70                 return 0;
  71             }
  72             if(name1 == null){
  73                 return 1;
  74             }
  75             if(name2 == null){
  76                 return -1;
  77             }
  78             return name1.compareTo(name2);
  79         }
  80     };
  81     @NonNls private static final String CLASS_ACCESS_METHOD_PREFIX = "class$";
  82
  83     private SerialVersionUIDBuilder(PsiClass clazz){
  84         super();
  85         this.clazz = clazz;
  86         nonPrivateMethods = new HashSet<MemberSignature>();
  87         final PsiMethod[] methods = clazz.getMethods();
  88         for(final PsiMethod method : methods){
  89             if(!method.isConstructor() &&
  90                     !method.hasModifierProperty(PsiModifier.PRIVATE)){
  91                 final MemberSignature methodSignature =
  92                         new MemberSignature(method);
  93                 nonPrivateMethods.add(methodSignature);
  94             }
  95         }
  96         nonPrivateFields = new HashSet<MemberSignature>();
  97         final PsiField[] fields = clazz.getFields();
  98         for(final PsiField field : fields){
  99             if(!field.hasModifierProperty(PsiModifier.PRIVATE) ||
 100                     !(field.hasModifierProperty(PsiModifier.STATIC) ||
 101                             field.hasModifierProperty(PsiModifier.TRANSIENT))){
 102                 final MemberSignature fieldSignature =
 103                         new MemberSignature(field);
 104                 nonPrivateFields.add(fieldSignature);
 105             }
 106         }
 107
 108         staticInitializers = new ArrayList<MemberSignature>();
 109         final PsiClassInitializer[] initializers = clazz.getInitializers();
 110         if(initializers.length > 0){
 111             for(final PsiClassInitializer initializer : initializers){
 112                 final PsiModifierList modifierList =
 113                         initializer.getModifierList();
 114                 if(modifierList != null &&
 115                         modifierList.hasModifierProperty(PsiModifier.STATIC)){
 116                     final MemberSignature initializerSignature =
 117                             MemberSignature.getStaticInitializerMemberSignature();
 118                     staticInitializers.add(initializerSignature);
 119                     break;
 120                 }
 121             }
 122         }
 123         if(staticInitializers.isEmpty()){
 124             final PsiField[] psiFields = clazz.getFields();
 125             for(final PsiField field : psiFields){
 126                 if(hasStaticInitializer(field)){
 127                     final MemberSignature initializerSignature =
 128                             MemberSignature.getStaticInitializerMemberSignature();
 129                     staticInitializers.add(initializerSignature);
 130                     break;
 131                 }
 132             }
 133         }
 134
 135         nonPrivateConstructors = new HashSet<MemberSignature>();
 136         final PsiMethod[] constructors = clazz.getConstructors();
 137         if(constructors.length == 0 && !clazz.isInterface()){
 138             // generated empty constructor if no constructor is defined in the source
 139             final MemberSignature constructorSignature;
 140             if(clazz.hasModifierProperty(PsiModifier.PUBLIC)){
 141                 constructorSignature = MemberSignature.getPublicConstructor();
 142             } else{
 143                 constructorSignature = MemberSignature.getPackagePrivateConstructor();
 144             }
 145             nonPrivateConstructors.add(constructorSignature);
 146         }
 147         for(final PsiMethod constructor : constructors){
 148             if(!constructor.hasModifierProperty(PsiModifier.PRIVATE)){
 149                 final MemberSignature constructorSignature =
 150                         new MemberSignature(constructor);
 151                 nonPrivateConstructors.add(constructorSignature);
 152             }
 153         }
 154     }
 155
 156     public static long computeDefaultSUID(PsiClass psiClass) {
 157         final Project project = psiClass.getProject();
 158         final GlobalSearchScope scope = GlobalSearchScope.allScope(project);
 159         final PsiClass serializable = JavaPsiFacade.getInstance(project).findClass(SERIALIZABLE_CLASS_NAME, scope);
 160         if (serializable == null) {
 161             // no jdk defined for project.
 162             return -1L;
 163         }
 164
 165         final boolean isSerializable = psiClass.isInheritor(serializable, true);
 166         if (!isSerializable) {
 167             return 0L;
 168         }
 169
 170         final SerialVersionUIDBuilder serialVersionUIDBuilder = new SerialVersionUIDBuilder(psiClass);
 171         try {
 172             final ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
 173             final DataOutputStream dataOutputStream = new DataOutputStream(byteArrayOutputStream);
 174
 175             final String className = PsiFormatUtil.getExternalName(psiClass);
 176             dataOutputStream.writeUTF(className);
 177
 178             final PsiModifierList classModifierList = psiClass.getModifierList();
 179             int classModifiers = classModifierList != null ? MemberSignature.calculateModifierBitmap(classModifierList) : 0;
 180             final MemberSignature[] methodSignatures = serialVersionUIDBuilder.getNonPrivateMethodSignatures();
 181             if (psiClass.isInterface()) {
 182                 classModifiers |= Modifier.INTERFACE;
 183                 if (methodSignatures.length == 0) {
 184                     // interfaces were not marked abstract when they did't have methods in java 1.0
 185                     // For serialization compatibility the abstract modifier is ignored.
 186                     classModifiers &= ~Modifier.ABSTRACT;
 187                 }
 188             }
 189             dataOutputStream.writeInt(classModifiers);
 190
 191             final PsiClass[] interfaces = psiClass.getInterfaces();
 192             Arrays.sort(interfaces, INTERFACE_COMPARATOR);
 193             for (PsiClass aInterfaces : interfaces) {
 194                 final String name = aInterfaces.getQualifiedName();
 195                 dataOutputStream.writeUTF(name);
 196             }
 197
 198             final MemberSignature[] fields = serialVersionUIDBuilder.getNonPrivateFields();
 199             Arrays.sort(fields);
 200             for (final MemberSignature field : fields) {
 201                 dataOutputStream.writeUTF(field.getName());
 202                 dataOutputStream.writeInt(field.getModifiers());
 203                 dataOutputStream.writeUTF(field.getSignature());
 204             }
 205
 206             final MemberSignature[] staticInitializers = serialVersionUIDBuilder.getStaticInitializers();
 207             for (final MemberSignature staticInitializer : staticInitializers) {
 208                 dataOutputStream.writeUTF(staticInitializer.getName());
 209                 dataOutputStream.writeInt(staticInitializer.getModifiers());
 210                 dataOutputStream.writeUTF(staticInitializer.getSignature());
 211             }
 212
 213             final MemberSignature[] constructors = serialVersionUIDBuilder.getNonPrivateConstructors();
 214             Arrays.sort(constructors);
 215             for (final MemberSignature constructor : constructors) {
 216                 dataOutputStream.writeUTF(constructor.getName());
 217                 dataOutputStream.writeInt(constructor.getModifiers());
 218                 dataOutputStream.writeUTF(constructor.getSignature());
 219             }
 220
 221             Arrays.sort(methodSignatures);
 222             for (final MemberSignature methodSignature : methodSignatures) {
 223                 dataOutputStream.writeUTF(methodSignature.getName());
 224                 dataOutputStream.writeInt(methodSignature.getModifiers());
 225                 dataOutputStream.writeUTF(methodSignature.getSignature());
 226             }
 227
 228             dataOutputStream.flush();
 229             @NonNls final String algorithm = "SHA";
 230             final MessageDigest digest = MessageDigest.getInstance(algorithm);
 231             final byte[] digestBytes = digest.digest(byteArrayOutputStream.toByteArray());
 232             long serialVersionUID = 0L;
 233             for (int i = Math.min(digestBytes.length, 8) - 1; i >= 0; i--) {
 234                 serialVersionUID = serialVersionUID << 8 | digestBytes[i] & 0xFF;
 235             }
 236             return serialVersionUID;
 237         }
 238         catch(IOException exception){
 239             final InternalError internalError = new InternalError(exception.getMessage());
 240             internalError.initCause(exception);
 241             throw internalError;
 242         }
 243         catch(NoSuchAlgorithmException exception){
 244             final SecurityException securityException = new SecurityException(exception.getMessage());
 245             securityException.initCause(exception);
 246             throw securityException;
 247         }
 248     }
 249
 250     private void createClassObjectAccessSynthetics(PsiType type){
 251         if(!classObjectAccessExpression){
 252             final MemberSignature syntheticMethod =
 253                     MemberSignature.getClassAccessMethodMemberSignature();
 254             nonPrivateMethods.add(syntheticMethod);
 255         }
 256         PsiType unwrappedType = type;
 257         @NonNls final StringBuffer fieldNameBuffer;
 258         if(type instanceof PsiArrayType){
 259             fieldNameBuffer = new StringBuffer();
 260             fieldNameBuffer.append("array");
 261             while(unwrappedType instanceof PsiArrayType){
 262                 final PsiArrayType arrayType = (PsiArrayType) unwrappedType;
 263                 unwrappedType = arrayType.getComponentType();
 264                 fieldNameBuffer.append('$');
 265             }
 266         } else{
 267             fieldNameBuffer = new StringBuffer(CLASS_ACCESS_METHOD_PREFIX);
 268         }
 269         if(unwrappedType instanceof PsiPrimitiveType){
 270             final PsiPrimitiveType primitiveType = (PsiPrimitiveType) unwrappedType;
 271             fieldNameBuffer.append(MemberSignature.createPrimitiveType(primitiveType));
 272         } else{
 273             final String text = unwrappedType.getCanonicalText().replace('.',
 274                                                                          '$');
 275             fieldNameBuffer.append(text);
 276         }
 277         final String fieldName = fieldNameBuffer.toString();
 278         final MemberSignature memberSignature =
 279                 new MemberSignature(fieldName, Modifier.STATIC,
 280                                     "Ljava/lang/Class;");
 281         if(!nonPrivateFields.contains(memberSignature)){
 282             nonPrivateFields.add(memberSignature);
 283         }
 284         classObjectAccessExpression = true;
 285     }
 286
 287     private String getAccessMethodIndex(PsiElement element){
 288         String cache = memberMap.get(element);
 289         if(cache == null){
 290             cache = String.valueOf(index);
 291             index++;
 292             memberMap.put(element, cache);
 293         }
 294         return cache;
 295     }
 296
 297     public MemberSignature[] getNonPrivateConstructors(){
 298         init();
 299         return nonPrivateConstructors.toArray(new MemberSignature[nonPrivateConstructors.size()]);
 300     }
 301
 302     public MemberSignature[] getNonPrivateFields(){
 303         init();
 304         return nonPrivateFields.toArray(new MemberSignature[nonPrivateFields.size()]);
 305     }
 306
 307     public MemberSignature[] getNonPrivateMethodSignatures(){
 308         init();
 309         return nonPrivateMethods.toArray(new MemberSignature[nonPrivateMethods.size()]);
 310     }
 311
 312     public MemberSignature[] getStaticInitializers(){
 313         init();
 314         return staticInitializers.toArray(new MemberSignature[staticInitializers.size()]);
 315     }
 316
 317     private static boolean hasStaticInitializer(PsiField field){
 318         if(field.hasModifierProperty(PsiModifier.STATIC)){
 319             final PsiManager manager = field.getManager();
 320             final Project project = manager.getProject();
 321             final GlobalSearchScope scope = GlobalSearchScope.allScope(project);
 322             final PsiExpression initializer = field.getInitializer();
 323             if(initializer == null){
 324                 return false;
 325             }
 326             final PsiType fieldType = field.getType();
 327             final PsiType stringType = PsiType.getJavaLangString(manager,
 328                                                                  scope);
 329             if(field.hasModifierProperty(PsiModifier.FINAL) &&
 330                     (fieldType instanceof PsiPrimitiveType ||
 331                             fieldType.equals(stringType))) {
 332                 return !PsiUtil.isConstantExpression(initializer);
 333             } else{
 334                 return true;
 335             }
 336         }
 337         return false;
 338     }
 339
 340     private void init(){
 341         if(index < 0){
 342             index = 0;
 343             clazz.acceptChildren(this);
 344         }
 345     }
 346
 347     @Override public void visitAssertStatement(PsiAssertStatement statement){
 348         super.visitAssertStatement(statement);
 349         if(assertStatement){
 350             return;
 351         }
 352         final MemberSignature memberSignature =
 353                 MemberSignature.getAssertionsDisabledFieldMemberSignature();
 354         nonPrivateFields.add(memberSignature);
 355         final PsiManager manager = clazz.getManager();
 356       final PsiElementFactory factory = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory();
 357         final PsiClassType classType = factory.createType(clazz);
 358         createClassObjectAccessSynthetics(classType);
 359         if(staticInitializers.isEmpty()){
 360             final MemberSignature initializerSignature =
 361                     MemberSignature.getStaticInitializerMemberSignature();
 362             staticInitializers.add(initializerSignature);
 363         }
 364         assertStatement = true;
 365     }
 366
 367     @Override public void visitClassObjectAccessExpression(
 368             PsiClassObjectAccessExpression expression){
 369         final PsiTypeElement operand = expression.getOperand();
 370         final PsiType type = operand.getType();
 371         if(!(type instanceof PsiPrimitiveType)){
 372             createClassObjectAccessSynthetics(type);
 373         }
 374         super.visitClassObjectAccessExpression(expression);
 375     }
 376
 377     @Override public void visitMethodCallExpression(
 378             @NotNull PsiMethodCallExpression methodCallExpression){
 379         // for navigating the psi tree in the order javac navigates its AST
 380         final PsiExpressionList argumentList =
 381                 methodCallExpression.getArgumentList();
 382         final PsiExpression[] expressions = argumentList.getExpressions();
 383         for(final PsiExpression expression : expressions){
 384             expression.accept(this);
 385         }
 386         final PsiReferenceExpression methodExpression =
 387                 methodCallExpression.getMethodExpression();
 388         methodExpression.accept(this);
 389     }
 390
 391     @Override public void visitReferenceElement(PsiJavaCodeReferenceElement reference){
 392         super.visitReferenceElement(reference);
 393         final PsiElement parentClass = ClassUtils.getContainingClass(reference);
 394         if(reference.getParent() instanceof PsiTypeElement){
 395             return;
 396         }
 397         final PsiElement element = reference.resolve();
 398         if(!(element instanceof PsiClass)){
 399             return;
 400         }
 401         final PsiClass elementParentClass =
 402                 ClassUtils.getContainingClass(element);
 403         if(elementParentClass == null ||
 404                 !elementParentClass.equals(clazz) ||
 405                 element.equals(parentClass)){
 406             return;
 407         }
 408         final PsiClass innerClass = (PsiClass) element;
 409         if(!innerClass.hasModifierProperty(PsiModifier.PRIVATE)){
 410             return;
 411         }
 412         final PsiMethod[] constructors = innerClass.getConstructors();
 413         if(constructors.length == 0){
 414             getAccessMethodIndex(innerClass);
 415         }
 416     }
 417
 418     @Override public void visitReferenceExpression(
 419             @NotNull PsiReferenceExpression expression){
 420         super.visitReferenceExpression(expression);
 421         final PsiElement element = expression.resolve();
 422         final PsiElement elementParentClass =
 423                 ClassUtils.getContainingClass(element);
 424         final PsiElement expressionParentClass =
 425                 ClassUtils.getContainingClass(expression);
 426         if(expressionParentClass == null || expressionParentClass
 427                 .equals(elementParentClass)){
 428             return;
 429         }
 430         PsiElement parentOfParentClass =
 431                 ClassUtils.getContainingClass(expressionParentClass);
 432         while(parentOfParentClass != null &&
 433                 !parentOfParentClass.equals(clazz)){
 434             if(!(expressionParentClass instanceof PsiAnonymousClass)){
 435                 getAccessMethodIndex(expressionParentClass);
 436             }
 437             getAccessMethodIndex(parentOfParentClass);
 438             parentOfParentClass = ClassUtils.getContainingClass(parentOfParentClass);
 439         }
 440         if(element instanceof PsiField){
 441             final PsiField field = (PsiField) element;
 442             if(field.hasModifierProperty(PsiModifier.PRIVATE)){
 443                 boolean isStatic = false;
 444                 final PsiType type = field.getType();
 445                 if(field.hasModifierProperty(PsiModifier.STATIC)){
 446                     if(field.hasModifierProperty(PsiModifier.FINAL) &&
 447                             type instanceof PsiPrimitiveType){
 448                         final PsiExpression initializer = field.getInitializer();
 449                         if(PsiUtil.isConstantExpression(initializer)){
 450                             return;
 451                         }
 452                     }
 453                     isStatic = true;
 454                 }
 455                 final String returnTypeSignature =
 456                         MemberSignature.createTypeSignature(type).replace('/',
 457                                                                           '.');
 458                 final String className = clazz.getQualifiedName();
 459                 @NonNls final StringBuilder signatureBuffer =
 460                         new StringBuilder("(");
 461                 if(!isStatic){
 462                     signatureBuffer.append('L').append(className).append(';');
 463                 }
 464                 final String accessMethodIndex = getAccessMethodIndex(field);
 465                 if(!field.getContainingClass().equals(clazz)){
 466                     return;
 467                 }
 468                 @NonNls String name = null;
 469                 final PsiElement parent = expression.getParent();
 470                 if(parent instanceof PsiAssignmentExpression){
 471                     final PsiAssignmentExpression assignment = (PsiAssignmentExpression) parent;
 472                     if(assignment.getLExpression().equals(expression)){
 473                         name = ACCESS_METHOD_NAME_PREFIX + accessMethodIndex +
 474                                 "02";
 475                         signatureBuffer.append(returnTypeSignature);
 476                     }
 477                 } else if(parent instanceof PsiPostfixExpression){
 478                     final PsiPostfixExpression postfixExpression =
 479                             (PsiPostfixExpression) parent;
 480                     final PsiJavaToken operationSign = postfixExpression.getOperationSign();
 481                     final IElementType tokenType = operationSign.getTokenType();
 482                     if(tokenType.equals(JavaTokenType.PLUSPLUS)){
 483                         name = ACCESS_METHOD_NAME_PREFIX + accessMethodIndex +
 484                                 "08";
 485                     } else if(tokenType.equals(JavaTokenType.MINUSMINUS)){
 486                         name = ACCESS_METHOD_NAME_PREFIX + accessMethodIndex +
 487                                 "10";
 488                     }
 489                 } else if(parent instanceof PsiPrefixExpression){
 490                     final PsiPrefixExpression prefixExpression = (PsiPrefixExpression) parent;
 491                     final PsiJavaToken operationSign = prefixExpression.getOperationSign();
 492                     final IElementType tokenType = operationSign.getTokenType();
 493                     if(tokenType.equals(JavaTokenType.PLUSPLUS)){
 494                         name = ACCESS_METHOD_NAME_PREFIX + accessMethodIndex +
 495                                 "04";
 496                     } else if(tokenType.equals(JavaTokenType.MINUSMINUS)){
 497                         name = ACCESS_METHOD_NAME_PREFIX + accessMethodIndex +
 498                                 "06";
 499                     }
 500                 }
 501                 if(name == null){
 502                     name = ACCESS_METHOD_NAME_PREFIX + accessMethodIndex + "00";
 503                 }
 504                 signatureBuffer.append(')').append(returnTypeSignature);
 505                 final String signature = signatureBuffer.toString();
 506                 final MemberSignature methodSignature =
 507                         new MemberSignature(name, Modifier.STATIC, signature);
 508                 nonPrivateMethods.add(methodSignature);
 509             }
 510         } else if(element instanceof PsiMethod){
 511             final PsiMethod method = (PsiMethod) element;
 512             if(method.hasModifierProperty(PsiModifier.PRIVATE) &&
 513                     method.getContainingClass().equals(clazz)){
 514                 final String signature;
 515                 if(method.hasModifierProperty(PsiModifier.STATIC)){
 516                     signature =
 517                             MemberSignature.createMethodSignature(method)
 518                                     .replace('/', '.');
 519                 } else{
 520                     final String returnTypeSignature =
 521                             MemberSignature.createTypeSignature(method.getReturnType())
 522                                     .replace('/', '.');
 523                     @NonNls final StringBuilder signatureBuffer =
 524                             new StringBuilder();
 525                     signatureBuffer.append("(L");
 526                     signatureBuffer.append(clazz.getQualifiedName())
 527                             .append(';');
 528                     final PsiParameter[] parameters = method.getParameterList()
 529                             .getParameters();
 530                     for(final PsiParameter parameter : parameters){
 531                         final PsiType type = parameter.getType();
 532                         final String typeSignature = MemberSignature.createTypeSignature(type)
 533                                 .replace('/', '.');
 534                         signatureBuffer.append(typeSignature);
 535                     }
 536                     signatureBuffer.append(')');
 537                     signatureBuffer.append(returnTypeSignature);
 538                     signature = signatureBuffer.toString();
 539                 }
 540                 final String accessMethodIndex = getAccessMethodIndex(method);
 541                 final MemberSignature methodSignature =
 542                         new MemberSignature(ACCESS_METHOD_NAME_PREFIX +
 543                                 accessMethodIndex + "00",
 544                                             Modifier.STATIC, signature);
 545                 nonPrivateMethods.add(methodSignature);
 546             }
 547         }
 548     }
 549 }