Merge remote-tracking branch 'origin/small_things' into small_things

4 files changed, 73 insertions, 36 deletions

diff --git a/javaparser-core/src/main/java/com/github/javaparser/resolution/types/ResolvedPrimitiveType.java b/javaparser-core/src/main/java/com/github/javaparser/resolution/types/ResolvedPrimitiveType.java
index 05b6102e9..4a7e29258 100644
--- a/javaparser-core/src/main/java/com/github/javaparser/resolution/types/ResolvedPrimitiveType.java
+++ b/javaparser-core/src/main/java/com/github/javaparser/resolution/types/ResolvedPrimitiveType.java
@@ -28,30 +28,17 @@ import java.util.List;
 /**
  * @author Federico Tomassetti
  */
-public class ResolvedPrimitiveType implements ResolvedType {
+public enum ResolvedPrimitiveType implements ResolvedType {
 
-    ///
-    /// Constants
-    ///
 
-    public static final ResolvedPrimitiveType BYTE = new ResolvedPrimitiveType("byte",
-            Byte.class.getCanonicalName(), Collections.emptyList());
-    public static final ResolvedPrimitiveType SHORT = new ResolvedPrimitiveType("short",
-            Short.class.getCanonicalName(), Collections.singletonList(BYTE));
-    public static final ResolvedPrimitiveType CHAR = new ResolvedPrimitiveType("char",
-            Character.class.getCanonicalName(), Collections.emptyList());
-    public static final ResolvedPrimitiveType INT = new ResolvedPrimitiveType("int",
-            Integer.class.getCanonicalName(), Arrays.asList(BYTE, SHORT, CHAR));
-    public static final ResolvedPrimitiveType LONG = new ResolvedPrimitiveType("long",
-            Long.class.getCanonicalName(), Arrays.asList(BYTE, SHORT, INT, CHAR));
-    public static final ResolvedPrimitiveType BOOLEAN = new ResolvedPrimitiveType("boolean",
-            Boolean.class.getCanonicalName(), Collections.emptyList());
-    public static final ResolvedPrimitiveType FLOAT = new ResolvedPrimitiveType("float",
-            Float.class.getCanonicalName(), Arrays.asList(LONG, INT, SHORT, BYTE, CHAR));
-    public static final ResolvedPrimitiveType DOUBLE = new ResolvedPrimitiveType("double",
-            Double.class.getCanonicalName(), Arrays.asList(FLOAT, LONG, INT, SHORT, BYTE, CHAR));
-    public static final List<ResolvedPrimitiveType> ALL = Arrays.asList(
-            INT, BOOLEAN, LONG, CHAR, FLOAT, DOUBLE, SHORT, BYTE);
+    BYTE("byte", Byte.class.getCanonicalName(), Collections.emptyList()),
+    SHORT("short", Short.class.getCanonicalName(), Collections.singletonList(BYTE)),
+    CHAR("char", Character.class.getCanonicalName(), Collections.emptyList()),
+    INT("int", Integer.class.getCanonicalName(), Arrays.asList(BYTE, SHORT, CHAR)),
+    LONG("long", Long.class.getCanonicalName(), Arrays.asList(BYTE, SHORT, INT, CHAR)),
+    BOOLEAN("boolean", Boolean.class.getCanonicalName(), Collections.emptyList()),
+    FLOAT("float", Float.class.getCanonicalName(), Arrays.asList(LONG, INT, SHORT, BYTE, CHAR)),
+    DOUBLE("double", Double.class.getCanonicalName(), Arrays.asList(FLOAT, LONG, INT, SHORT, BYTE, CHAR));
 
     ///
     /// Fields
@@ -69,7 +56,7 @@ public class ResolvedPrimitiveType implements ResolvedType {
 
     public static ResolvedType byName(String name) {
         name = name.toLowerCase();
-        for (ResolvedPrimitiveType ptu : ALL) {
+        for (ResolvedPrimitiveType ptu : values()) {
             if (ptu.describe().equals(name)) {
                 return ptu;
             }
diff --git a/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/resolution/typeinference/TypeHelper.java b/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/resolution/typeinference/TypeHelper.java
index 604689b78..01d041d11 100644
--- a/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/resolution/typeinference/TypeHelper.java
+++ b/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/resolution/typeinference/TypeHelper.java
@@ -137,7 +137,7 @@ public class TypeHelper {
         if (!referenceType.isReferenceType()) {
             return false;
         }
-        return ResolvedPrimitiveType.ALL.stream().anyMatch(pt -> referenceType.asReferenceType().getQualifiedName().equals(pt.getBoxTypeQName()));
+        return Arrays.stream(ResolvedPrimitiveType.values()).anyMatch(pt -> referenceType.asReferenceType().getQualifiedName().equals(pt.getBoxTypeQName()));
     }
 
     private static ResolvedType toUnboxedType(ResolvedReferenceType referenceType) {
@@ -149,7 +149,7 @@ public class TypeHelper {
     }
 
     private static boolean areCompatibleThroughWideningReferenceConversion(ResolvedType s, ResolvedType t) {
-        Optional<ResolvedPrimitiveType> correspondingPrimitiveTypeForS = ResolvedPrimitiveType.ALL.stream().filter(pt -> pt.getBoxTypeQName().equals(s.asReferenceType().getQualifiedName())).findFirst();
+        Optional<ResolvedPrimitiveType> correspondingPrimitiveTypeForS = Arrays.stream(ResolvedPrimitiveType.values()).filter(pt -> pt.getBoxTypeQName().equals(s.asReferenceType().getQualifiedName())).findFirst();
         if (!correspondingPrimitiveTypeForS.isPresent()) {
             return false;
         }
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/resolution/types/ResolvedPrimitiveTypeTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/resolution/types/ResolvedPrimitiveTypeTest.java
new file mode 100644
index 000000000..494b2b2e9
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/resolution/types/ResolvedPrimitiveTypeTest.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2016 Federico Tomassetti
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.github.javaparser.resolution.types;
+
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class ResolvedPrimitiveTypeTest extends AbstractResolutionTest {
+
+    private String exampleOfSwitch(ResolvedPrimitiveType rpt) {
+        switch (rpt) {
+            case INT:
+                return "I";
+            case BYTE:
+                return "B";
+            case DOUBLE:
+                return "D";
+            default:
+                return "U";
+        }
+    }
+
+    @Test
+    public void tryTheSwitchStatement() {
+        assertEquals("U", exampleOfSwitch(ResolvedPrimitiveType.BOOLEAN));
+        assertEquals("U", exampleOfSwitch(ResolvedPrimitiveType.CHAR));
+        assertEquals("B", exampleOfSwitch(ResolvedPrimitiveType.BYTE));
+        assertEquals("U", exampleOfSwitch(ResolvedPrimitiveType.SHORT));
+        assertEquals("I", exampleOfSwitch(ResolvedPrimitiveType.INT));
+        assertEquals("U", exampleOfSwitch(ResolvedPrimitiveType.LONG));
+        assertEquals("U", exampleOfSwitch(ResolvedPrimitiveType.FLOAT));
+        assertEquals("D", exampleOfSwitch(ResolvedPrimitiveType.DOUBLE));
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/model/typesystem/PrimitiveTypeTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/model/typesystem/PrimitiveTypeTest.java
index 62cb15fbc..3679dbd41 100644
--- a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/model/typesystem/PrimitiveTypeTest.java
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/model/typesystem/PrimitiveTypeTest.java
@@ -74,56 +74,56 @@ public class PrimitiveTypeTest {
 
     @Test
     public void testIsArray() {
-        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.ALL) {
+        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.values()) {
             assertEquals(false, ptu.isArray());
         }
     }
 
     @Test
     public void testIsPrimitive() {
-        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.ALL) {
+        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.values()) {
             assertEquals(true, ptu.isPrimitive());
         }
     }
 
     @Test
     public void testIsNull() {
-        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.ALL) {
+        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.values()) {
             assertEquals(false, ptu.isNull());
         }
     }
 
     @Test
     public void testIsReference() {
-        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.ALL) {
+        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.values()) {
             assertEquals(false, ptu.isReference());
         }
     }
 
     @Test
     public void testIsReferenceType() {
-        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.ALL) {
+        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.values()) {
             assertEquals(false, ptu.isReferenceType());
         }
     }
 
     @Test
     public void testIsVoid() {
-        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.ALL) {
+        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.values()) {
             assertEquals(false, ptu.isVoid());
         }
     }
 
     @Test
     public void testIsTypeVariable() {
-        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.ALL) {
+        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.values()) {
             assertEquals(false, ptu.isTypeVariable());
         }
     }
 
     @Test
     public void testAsReferenceTypeUsage() {
-        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.ALL) {
+        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.values()) {
             try {
                 ptu.asReferenceType();
                 fail();
@@ -134,7 +134,7 @@ public class PrimitiveTypeTest {
 
     @Test
     public void testAsTypeParameter() {
-        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.ALL) {
+        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.values()) {
             try {
                 ptu.asTypeParameter();
                 fail();
@@ -145,7 +145,7 @@ public class PrimitiveTypeTest {
 
     @Test
     public void testAsArrayTypeUsage() {
-        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.ALL) {
+        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.values()) {
             try {
                 ptu.asArrayType();
                 fail();
@@ -318,7 +318,7 @@ public class PrimitiveTypeTest {
 
     @Test
     public void testIsAssignableByAnythingElse() {
-        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.ALL) {
+        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.values()) {
             assertEquals(false, ptu.isAssignableBy(OBJECT));
             assertEquals(false, ptu.isAssignableBy(STRING));
             assertEquals(false, ptu.isAssignableBy(NullType.INSTANCE));