/plug-ins/helios/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/BindingComparator.java

https://github.com/vazexqi/CodingSpectator · Java · 313 lines · 251 code · 21 blank · 41 comment · 111 complexity · f76f06adb75a3ccd18a1845fb1060599 MD5 · raw file 

    

  1. /*******************************************************************************

    2. 

  2.  * Copyright (c) 2004, 2008 IBM Corporation and others.

    3. 

  3.  * All rights reserved. This program and the accompanying materials

    4. 

  4.  * are made available under the terms of the Eclipse Public License v1.0

    5. 

  5.  * which accompanies this distribution, and is available at

    6. 

  6.  * http://www.eclipse.org/legal/epl-v10.html

    7. 

  7.  *

    8. 

  8.  * Contributors:

    9. 

  9.  *     IBM Corporation - initial API and implementation

    10. 

  10.  *******************************************************************************/

    11. 

  11. package org.eclipse.jdt.core.dom;

    12. 

  12. 

    13. 

  13. import java.util.HashSet;

    14. 

  14. 

    15. 

  15. import org.eclipse.jdt.core.compiler.CharOperation;

    16. 

  16. import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;

    17. 

  17. import org.eclipse.jdt.internal.compiler.lookup.Binding;

    18. 

  18. import org.eclipse.jdt.internal.compiler.lookup.CaptureBinding;

    19. 

  19. import org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers;

    20. 

  20. import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;

    21. 

  21. import org.eclipse.jdt.internal.compiler.lookup.ImportBinding;

    22. 

  22. import org.eclipse.jdt.internal.compiler.lookup.ParameterizedTypeBinding;

    23. 

  23. import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;

    24. 

  24. import org.eclipse.jdt.internal.compiler.lookup.TypeVariableBinding;

    25. 

  25. import org.eclipse.jdt.internal.compiler.lookup.VariableBinding;

    26. 

  26. import org.eclipse.jdt.internal.compiler.lookup.WildcardBinding;

    27. 

  27. 

    28. 

  28. /**

    29. 

  29.  * Internal helper class for comparing bindings.

    30. 

  30.  * 

    31. 

  31.  * @since 3.1

    32. 

  32.  */

    33. 

  33. class BindingComparator {

    34. 

  34. 	/**

    35. 

  35. 	 * @param bindings

    36. 

  36. 	 * @param otherBindings

    37. 

  37. 	 * @return true if both parameters are equals, false otherwise

    38. 

  38. 	 */

    39. 

  39. 	static boolean isEqual(TypeVariableBinding[] bindings, TypeVariableBinding[] otherBindings) {

    40. 

  40. 		if (bindings == null) {

    41. 

  41. 			return otherBindings == null;

    42. 

  42. 		}

    43. 

  43. 		if (otherBindings == null) {

    44. 

  44. 			return false;

    45. 

  45. 		}

    46. 

  46. 		int length= bindings.length;

    47. 

  47. 		int otherLength= otherBindings.length;

    48. 

  48. 		if (length != otherLength) {

    49. 

  49. 			return false;

    50. 

  50. 		}

    51. 

  51. 		for (int i= 0; i < length; i++) {

    52. 

  52. 			TypeVariableBinding typeVariableBinding= bindings[i];

    53. 

  53. 			TypeVariableBinding typeVariableBinding2= otherBindings[i];

    54. 

  54. 			if (!isEqual(typeVariableBinding, typeVariableBinding2)) {

    55. 

  55. 				return false;

    56. 

  56. 			}

    57. 

  57. 		}

    58. 

  58. 		return true;

    59. 

  59. 	}

    60. 

  60. 

    61. 

  61. 	/**

    62. 

  62. 	 * @param declaringElement

    63. 

  63. 	 * @param declaringElement2

    64. 

  64. 	 * @return true if both parameters are equals, false otherwise

    65. 

  65. 	 */

    66. 

  66. 	static boolean isEqual(Binding declaringElement, Binding declaringElement2, HashSet visitedTypes) {

    67. 

  67. 		if (declaringElement instanceof org.eclipse.jdt.internal.compiler.lookup.TypeBinding) {

    68. 

  68. 			if (!(declaringElement2 instanceof org.eclipse.jdt.internal.compiler.lookup.TypeBinding)) {

    69. 

  69. 				return false;

    70. 

  70. 			}

    71. 

  71. 			return isEqual((org.eclipse.jdt.internal.compiler.lookup.TypeBinding)declaringElement,

    72. 

  72. 					(org.eclipse.jdt.internal.compiler.lookup.TypeBinding)declaringElement2,

    73. 

  73. 					visitedTypes);

    74. 

  74. 		} else if (declaringElement instanceof org.eclipse.jdt.internal.compiler.lookup.MethodBinding) {

    75. 

  75. 			if (!(declaringElement2 instanceof org.eclipse.jdt.internal.compiler.lookup.MethodBinding)) {

    76. 

  76. 				return false;

    77. 

  77. 			}

    78. 

  78. 			return isEqual((org.eclipse.jdt.internal.compiler.lookup.MethodBinding)declaringElement,

    79. 

  79. 					(org.eclipse.jdt.internal.compiler.lookup.MethodBinding)declaringElement2,

    80. 

  80. 					visitedTypes);

    81. 

  81. 		} else if (declaringElement instanceof VariableBinding) {

    82. 

  82. 			if (!(declaringElement2 instanceof VariableBinding)) {

    83. 

  83. 				return false;

    84. 

  84. 			}

    85. 

  85. 			return isEqual((VariableBinding)declaringElement,

    86. 

  86. 					(VariableBinding)declaringElement2);

    87. 

  87. 		} else if (declaringElement instanceof org.eclipse.jdt.internal.compiler.lookup.PackageBinding) {

    88. 

  88. 			if (!(declaringElement2 instanceof org.eclipse.jdt.internal.compiler.lookup.PackageBinding)) {

    89. 

  89. 				return false;

    90. 

  90. 			}

    91. 

  91. 			org.eclipse.jdt.internal.compiler.lookup.PackageBinding packageBinding= (org.eclipse.jdt.internal.compiler.lookup.PackageBinding)declaringElement;

    92. 

  92. 			org.eclipse.jdt.internal.compiler.lookup.PackageBinding packageBinding2= (org.eclipse.jdt.internal.compiler.lookup.PackageBinding)declaringElement2;

    93. 

  93. 			return CharOperation.equals(packageBinding.compoundName, packageBinding2.compoundName);

    94. 

  94. 		} else if (declaringElement instanceof ImportBinding) {

    95. 

  95. 			if (!(declaringElement2 instanceof ImportBinding)) {

    96. 

  96. 				return false;

    97. 

  97. 			}

    98. 

  98. 			ImportBinding importBinding= (ImportBinding)declaringElement;

    99. 

  99. 			ImportBinding importBinding2= (ImportBinding)declaringElement2;

    100. 

  100. 			return importBinding.isStatic() == importBinding2.isStatic()

    101. 

  101. 					&& importBinding.onDemand == importBinding2.onDemand

    102. 

  102. 					&& CharOperation.equals(importBinding.compoundName, importBinding2.compoundName);

    103. 

  103. 		}

    104. 

  104. 		return false;

    105. 

  105. 	}

    106. 

  106. 

    107. 

  107. 	static boolean isEqual(org.eclipse.jdt.internal.compiler.lookup.MethodBinding methodBinding,

    108. 

  108. 			org.eclipse.jdt.internal.compiler.lookup.MethodBinding methodBinding2) {

    109. 

  109. 		return isEqual(methodBinding, methodBinding2, new HashSet());

    110. 

  110. 	}

    111. 

  111. 

    112. 

  112. 	static boolean isEqual(org.eclipse.jdt.internal.compiler.lookup.MethodBinding methodBinding,

    113. 

  113. 			org.eclipse.jdt.internal.compiler.lookup.MethodBinding methodBinding2,

    114. 

  114. 			HashSet visitedTypes) {

    115. 

  115. 		if (methodBinding == null) {

    116. 

  116. 			return methodBinding2 == null;

    117. 

  117. 		}

    118. 

  118. 		if (methodBinding2 == null)

    119. 

  119. 			return false;

    120. 

  120. 		return CharOperation.equals(methodBinding.selector, methodBinding2.selector)

    121. 

  121. 				&& isEqual(methodBinding.returnType, methodBinding2.returnType, visitedTypes)

    122. 

  122. 				&& isEqual(methodBinding.thrownExceptions, methodBinding2.thrownExceptions, visitedTypes)

    123. 

  123. 				&& isEqual(methodBinding.declaringClass, methodBinding2.declaringClass, visitedTypes)

    124. 

  124. 				&& isEqual(methodBinding.typeVariables, methodBinding2.typeVariables, visitedTypes)

    125. 

  125. 				&& isEqual(methodBinding.parameters, methodBinding2.parameters, visitedTypes);

    126. 

  126. 	}

    127. 

  127. 

    128. 

  128. 	static boolean isEqual(VariableBinding variableBinding, VariableBinding variableBinding2) {

    129. 

  129. 		return (variableBinding.modifiers & ExtraCompilerModifiers.AccJustFlag) == (variableBinding2.modifiers & ExtraCompilerModifiers.AccJustFlag)

    130. 

  130. 				&& CharOperation.equals(variableBinding.name, variableBinding2.name)

    131. 

  131. 				&& isEqual(variableBinding.type, variableBinding2.type)

    132. 

  132. 				&& (variableBinding.id == variableBinding2.id);

    133. 

  133. 	}

    134. 

  134. 

    135. 

  135. 	static boolean isEqual(FieldBinding fieldBinding, FieldBinding fieldBinding2) {

    136. 

  136. 		HashSet visitedTypes= new HashSet();

    137. 

  137. 		return (fieldBinding.modifiers & ExtraCompilerModifiers.AccJustFlag) == (fieldBinding2.modifiers & ExtraCompilerModifiers.AccJustFlag)

    138. 

  138. 				&& CharOperation.equals(fieldBinding.name, fieldBinding2.name)

    139. 

  139. 				&& isEqual(fieldBinding.type, fieldBinding2.type, visitedTypes)

    140. 

  140. 				&& isEqual(fieldBinding.declaringClass, fieldBinding2.declaringClass, visitedTypes);

    141. 

  141. 	}

    142. 

  142. 

    143. 

  143. 	/**

    144. 

  144. 	 * @param bindings

    145. 

  145. 	 * @param otherBindings

    146. 

  146. 	 * @return true if both parameters are equals, false otherwise

    147. 

  147. 	 */

    148. 

  148. 	static boolean isEqual(org.eclipse.jdt.internal.compiler.lookup.TypeBinding[] bindings, org.eclipse.jdt.internal.compiler.lookup.TypeBinding[] otherBindings) {

    149. 

  149. 		return isEqual(bindings, otherBindings, new HashSet());

    150. 

  150. 	}

    151. 

  151. 

    152. 

  152. 	/**

    153. 

  153. 	 * @param bindings

    154. 

  154. 	 * @param otherBindings

    155. 

  155. 	 * @return true if both parameters are equals, false otherwise

    156. 

  156. 	 */

    157. 

  157. 	static boolean isEqual(org.eclipse.jdt.internal.compiler.lookup.TypeBinding[] bindings, org.eclipse.jdt.internal.compiler.lookup.TypeBinding[] otherBindings, HashSet visitedTypes) {

    158. 

  158. 		if (bindings == null) {

    159. 

  159. 			return otherBindings == null;

    160. 

  160. 		}

    161. 

  161. 		if (otherBindings == null) {

    162. 

  162. 			return false;

    163. 

  163. 		}

    164. 

  164. 		int length= bindings.length;

    165. 

  165. 		int otherLength= otherBindings.length;

    166. 

  166. 		if (length != otherLength) {

    167. 

  167. 			return false;

    168. 

  168. 		}

    169. 

  169. 		for (int i= 0; i < length; i++) {

    170. 

  170. 			if (!isEqual(bindings[i], otherBindings[i], visitedTypes)) {

    171. 

  171. 				return false;

    172. 

  172. 			}

    173. 

  173. 		}

    174. 

  174. 		return true;

    175. 

  175. 	}

    176. 

  176. 

    177. 

  177. 	static boolean isEqual(org.eclipse.jdt.internal.compiler.lookup.TypeBinding typeBinding, org.eclipse.jdt.internal.compiler.lookup.TypeBinding typeBinding2, HashSet visitedTypes) {

    178. 

  178. 		if (typeBinding == typeBinding2)

    179. 

  179. 			return true;

    180. 

  180. 		if (typeBinding == null || typeBinding2 == null)

    181. 

  181. 			return false;

    182. 

  182. 

    183. 

  183. 		switch (typeBinding.kind()) {

    184. 

  184. 			case Binding.BASE_TYPE:

    185. 

  185. 				if (!typeBinding2.isBaseType()) {

    186. 

  186. 					return false;

    187. 

  187. 				}

    188. 

  188. 				return typeBinding.id == typeBinding2.id;

    189. 

  189. 

    190. 

  190. 			case Binding.ARRAY_TYPE:

    191. 

  191. 				if (!typeBinding2.isArrayType()) {

    192. 

  192. 					return false;

    193. 

  193. 				}

    194. 

  194. 				return typeBinding.dimensions() == typeBinding2.dimensions()

    195. 

  195. 						&& isEqual(typeBinding.leafComponentType(), typeBinding2.leafComponentType(), visitedTypes);

    196. 

  196. 

    197. 

  197. 			case Binding.PARAMETERIZED_TYPE:

    198. 

  198. 				if (!typeBinding2.isParameterizedType()) {

    199. 

  199. 					return false;

    200. 

  200. 				}

    201. 

  201. 				ParameterizedTypeBinding parameterizedTypeBinding= (ParameterizedTypeBinding)typeBinding;

    202. 

  202. 				ParameterizedTypeBinding parameterizedTypeBinding2= (ParameterizedTypeBinding)typeBinding2;

    203. 

  203. 				return CharOperation.equals(parameterizedTypeBinding.compoundName, parameterizedTypeBinding2.compoundName)

    204. 

  204. 						&& (parameterizedTypeBinding.modifiers & (ExtraCompilerModifiers.AccJustFlag | ClassFileConstants.AccInterface | ClassFileConstants.AccEnum | ClassFileConstants.AccAnnotation))

    205. 

  205. 							== (parameterizedTypeBinding2.modifiers & (ExtraCompilerModifiers.AccJustFlag | ClassFileConstants.AccInterface | ClassFileConstants.AccEnum | ClassFileConstants.AccAnnotation))

    206. 

  206. 						&& isEqual(parameterizedTypeBinding.arguments, parameterizedTypeBinding2.arguments, visitedTypes)

    207. 

  207. 						&& isEqual(parameterizedTypeBinding.enclosingType(), parameterizedTypeBinding2.enclosingType(), visitedTypes);

    208. 

  208. 

    209. 

  209. 			case Binding.WILDCARD_TYPE:

    210. 

  210. 				if (typeBinding2.kind() != Binding.WILDCARD_TYPE) {

    211. 

  211. 					return false;

    212. 

  212. 				}

    213. 

  213. 				WildcardBinding wildcardBinding= (WildcardBinding)typeBinding;

    214. 

  214. 				WildcardBinding wildcardBinding2= (WildcardBinding)typeBinding2;

    215. 

  215. 				return isEqual(wildcardBinding.bound, wildcardBinding2.bound, visitedTypes)

    216. 

  216. 						&& wildcardBinding.boundKind == wildcardBinding2.boundKind;

    217. 

  217. 

    218. 

  218. 			case Binding.INTERSECTION_TYPE:

    219. 

  219. 				if (typeBinding2.kind() != Binding.INTERSECTION_TYPE) {

    220. 

  220. 					return false;

    221. 

  221. 				}

    222. 

  222. 				WildcardBinding intersectionBinding= (WildcardBinding)typeBinding;

    223. 

  223. 				WildcardBinding intersectionBinding2= (WildcardBinding)typeBinding2;

    224. 

  224. 				return isEqual(intersectionBinding.bound, intersectionBinding2.bound, visitedTypes)

    225. 

  225. 						&& isEqual(intersectionBinding.otherBounds, intersectionBinding2.otherBounds, visitedTypes);

    226. 

  226. 

    227. 

  227. 			case Binding.TYPE_PARAMETER:

    228. 

  228. 				if (!(typeBinding2.isTypeVariable())) {

    229. 

  229. 					return false;

    230. 

  230. 				}

    231. 

  231. 				if (typeBinding.isCapture()) {

    232. 

  232. 					if (!(typeBinding2.isCapture())) {

    233. 

  233. 						return false;

    234. 

  234. 					}

    235. 

  235. 					CaptureBinding captureBinding= (CaptureBinding)typeBinding;

    236. 

  236. 					CaptureBinding captureBinding2= (CaptureBinding)typeBinding2;

    237. 

  237. 					if (captureBinding.position == captureBinding2.position) {

    238. 

  238. 						if (visitedTypes.contains(typeBinding))

    239. 

  239. 							return true;

    240. 

  240. 						visitedTypes.add(typeBinding);

    241. 

  241. 

    242. 

  242. 						return isEqual(captureBinding.wildcard, captureBinding2.wildcard, visitedTypes)

    243. 

  243. 								&& isEqual(captureBinding.sourceType, captureBinding2.sourceType, visitedTypes);

    244. 

  244. 					}

    245. 

  245. 					return false;

    246. 

  246. 				}

    247. 

  247. 				TypeVariableBinding typeVariableBinding= (TypeVariableBinding)typeBinding;

    248. 

  248. 				TypeVariableBinding typeVariableBinding2= (TypeVariableBinding)typeBinding2;

    249. 

  249. 				if (CharOperation.equals(typeVariableBinding.sourceName, typeVariableBinding2.sourceName)) {

    250. 

  250. 					if (visitedTypes.contains(typeBinding))

    251. 

  251. 						return true;

    252. 

  252. 					visitedTypes.add(typeBinding);

    253. 

  253. 

    254. 

  254. 					return isEqual(typeVariableBinding.declaringElement, typeVariableBinding2.declaringElement, visitedTypes)

    255. 

  255. 							&& isEqual(typeVariableBinding.superclass(), typeVariableBinding2.superclass(), visitedTypes)

    256. 

  256. 							&& isEqual(typeVariableBinding.superInterfaces(), typeVariableBinding2.superInterfaces(), visitedTypes);

    257. 

  257. 				}

    258. 

  258. 				return false;

    259. 

  259. 			case Binding.GENERIC_TYPE:

    260. 

  260. 				if (!typeBinding2.isGenericType()) {

    261. 

  261. 					return false;

    262. 

  262. 				}

    263. 

  263. 				ReferenceBinding referenceBinding= (ReferenceBinding)typeBinding;

    264. 

  264. 				ReferenceBinding referenceBinding2= (ReferenceBinding)typeBinding2;

    265. 

  265. 				return CharOperation.equals(referenceBinding.compoundName, referenceBinding2.compoundName)

    266. 

  266. 						&& (referenceBinding.modifiers & (ExtraCompilerModifiers.AccJustFlag | ClassFileConstants.AccInterface | ClassFileConstants.AccEnum | ClassFileConstants.AccAnnotation))

    267. 

  267. 							== (referenceBinding2.modifiers & (ExtraCompilerModifiers.AccJustFlag | ClassFileConstants.AccInterface | ClassFileConstants.AccEnum | ClassFileConstants.AccAnnotation))

    268. 

  268. 						&& isEqual(referenceBinding.typeVariables(), referenceBinding2.typeVariables(), visitedTypes)

    269. 

  269. 						&& isEqual(referenceBinding.enclosingType(), referenceBinding2.enclosingType(), visitedTypes);

    270. 

  270. 

    271. 

  271. 			case Binding.RAW_TYPE:

    272. 

  272. 			default:

    273. 

  273. 				if (!(typeBinding2 instanceof ReferenceBinding)) {

    274. 

  274. 					return false;

    275. 

  275. 				}

    276. 

  276. 				referenceBinding= (ReferenceBinding)typeBinding;

    277. 

  277. 				referenceBinding2= (ReferenceBinding)typeBinding2;

    278. 

  278. 				char[] constantPoolName= referenceBinding.constantPoolName();

    279. 

  279. 				char[] constantPoolName2= referenceBinding2.constantPoolName();

    280. 

  280. 				// see https://bugs.eclipse.org/bugs/show_bug.cgi?id=116833

    281. 

  281. 				if (constantPoolName == null) {

    282. 

  282. 					if (constantPoolName2 != null) {

    283. 

  283. 						return false;

    284. 

  284. 					}

    285. 

  285. 					if (!CharOperation.equals(referenceBinding.computeUniqueKey(), referenceBinding2.computeUniqueKey())) {

    286. 

  286. 						return false;

    287. 

  287. 					}

    288. 

  288. 				} else {

    289. 

  289. 					if (constantPoolName2 == null) {

    290. 

  290. 						return false;

    291. 

  291. 					}

    292. 

  292. 					if (!CharOperation.equals(constantPoolName, constantPoolName2)) {

    293. 

  293. 						return false;

    294. 

  294. 					}

    295. 

  295. 				}

    296. 

  296. 				return CharOperation.equals(referenceBinding.compoundName, referenceBinding2.compoundName)

    297. 

  297. 						&& (!referenceBinding2.isGenericType())

    298. 

  298. 						&& (referenceBinding.isRawType() == referenceBinding2.isRawType())

    299. 

  299. 						&& ((referenceBinding.modifiers & ~ClassFileConstants.AccSuper) & (ExtraCompilerModifiers.AccJustFlag | ClassFileConstants.AccInterface | ClassFileConstants.AccEnum | ClassFileConstants.AccAnnotation))

    300. 

  300. 							== ((referenceBinding2.modifiers & ~ClassFileConstants.AccSuper) & (ExtraCompilerModifiers.AccJustFlag | ClassFileConstants.AccInterface | ClassFileConstants.AccEnum | ClassFileConstants.AccAnnotation))

    301. 

  301. 						&& isEqual(referenceBinding.enclosingType(), referenceBinding2.enclosingType(), visitedTypes);

    302. 

  302. 		}

    303. 

  303. 	}

    304. 

  304. 

    305. 

  305. 	/**

    306. 

  306. 	 * @param typeBinding

    307. 

  307. 	 * @param typeBinding2

    308. 

  308. 	 * @return true if both parameters are equals, false otherwise

    309. 

  309. 	 */

    310. 

  310. 	static boolean isEqual(org.eclipse.jdt.internal.compiler.lookup.TypeBinding typeBinding, org.eclipse.jdt.internal.compiler.lookup.TypeBinding typeBinding2) {

    311. 

  311. 		return isEqual(typeBinding, typeBinding2, new HashSet());

    312. 

  312. 	}

    313. 

  313. }
    314.