@@ -62,22 +62,17 @@ public static String formatCheckedType(Type t) {
6262 case kindNull :
6363 return "null" ;
6464 case kindPrimitive :
65- switch (t .getPrimitive ()) {
66- case UINT64 :
67- return "uint" ;
68- case INT64 :
69- return "int" ;
70- case BOOL :
71- return "bool" ;
72- case BYTES :
73- return "bytes" ;
74- case DOUBLE :
75- return "double" ;
76- case STRING :
77- return "string" ;
78- }
79- // unrecognizes & not-specified - ignore above
80- return t .getPrimitive ().toString ().toLowerCase (Locale .ROOT ).trim ();
65+ return switch (t .getPrimitive ()) {
66+ case UINT64 -> "uint" ;
67+ case INT64 -> "int" ;
68+ case BOOL -> "bool" ;
69+ case BYTES -> "bytes" ;
70+ case DOUBLE -> "double" ;
71+ case STRING -> "string" ;
72+ default ->
73+ // unrecognizes & not-specified - ignore above
74+ t .getPrimitive ().toString ().toLowerCase (Locale .ROOT ).trim ();
75+ };
8176 case kindWellKnown :
8277 switch (t .getWellKnown ()) {
8378 case ANY :
@@ -196,14 +191,11 @@ private static void formatCheckedTypePrimitive(StringBuilder sb, Type.PrimitiveT
196191 static boolean isDyn (Type t ) {
197192 // Note: object type values that are well-known and map to a DYN value in practice
198193 // are sanitized prior to being added to the environment.
199- switch (kindOf (t )) {
200- case kindDyn :
201- return true ;
202- case kindWellKnown :
203- return t .getWellKnown () == WellKnownType .ANY ;
204- default :
205- return false ;
206- }
194+ return switch (kindOf (t )) {
195+ case kindDyn -> true ;
196+ case kindWellKnown -> t .getWellKnown () == WellKnownType .ANY ;
197+ default -> false ;
198+ };
207199 }
208200
209201 /** isDynOrError returns true if the input is either an Error, DYN, or well-known ANY message. */
@@ -356,28 +348,22 @@ static boolean internalIsAssignable(Mapping m, Type t1, Type t2) {
356348 }
357349
358350 // Test for when the types must agree.
359- switch (kind1 ) {
351+ return switch (kind1 ) {
360352 // ERROR, TYPE_PARAM, and DYN handled above.
361- case kindAbstract :
362- return internalIsAssignableAbstractType (m , t1 .getAbstractType (), t2 .getAbstractType ());
363- case kindFunction :
364- return internalIsAssignableFunction (m , t1 .getFunction (), t2 .getFunction ());
365- case kindList :
366- return internalIsAssignable (
367- m , t1 .getListType ().getElemType (), t2 .getListType ().getElemType ());
368- case kindMap :
369- return internalIsAssignableMap (m , t1 .getMapType (), t2 .getMapType ());
370- case kindObject :
371- return t1 .getMessageType ().equals (t2 .getMessageType ());
372- case kindType :
373- // A type is a type is a type, any additional parameterization of the
374- // type cannot affect method resolution or assignability.
375- return true ;
376- case kindWellKnown :
377- return t1 .getWellKnown () == t2 .getWellKnown ();
378- default :
379- return false ;
380- }
353+ case kindAbstract ->
354+ internalIsAssignableAbstractType (m , t1 .getAbstractType (), t2 .getAbstractType ());
355+ case kindFunction -> internalIsAssignableFunction (m , t1 .getFunction (), t2 .getFunction ());
356+ case kindList ->
357+ internalIsAssignable (m , t1 .getListType ().getElemType (), t2 .getListType ().getElemType ());
358+ case kindMap -> internalIsAssignableMap (m , t1 .getMapType (), t2 .getMapType ());
359+ case kindObject -> t1 .getMessageType ().equals (t2 .getMessageType ());
360+ case kindType ->
361+ // A type is a type is a type, any additional parameterization of the
362+ // type cannot affect method resolution or assignability.
363+ true ;
364+ case kindWellKnown -> t1 .getWellKnown () == t2 .getWellKnown ();
365+ default -> false ;
366+ };
381367 }
382368
383369 /**
@@ -429,31 +415,22 @@ static boolean internalIsAssignableMap(Mapping m, MapType m1, MapType m2) {
429415
430416 /** internalIsAssignableNull returns true if the type is nullable. */
431417 static boolean internalIsAssignableNull (Type t ) {
432- switch (kindOf (t )) {
433- case kindAbstract :
434- case kindObject :
435- case kindNull :
436- case kindWellKnown :
437- case kindWrapper :
438- return true ;
439- default :
440- return false ;
441- }
418+ return switch (kindOf (t )) {
419+ case kindAbstract , kindObject , kindNull , kindWellKnown , kindWrapper -> true ;
420+ default -> false ;
421+ };
442422 }
443423
444424 /**
445425 * internalIsAssignablePrimitive returns true if the target type is the same or if it is a wrapper
446426 * for the primitive type.
447427 */
448428 static boolean internalIsAssignablePrimitive (PrimitiveType p , Type target ) {
449- switch (kindOf (target )) {
450- case kindPrimitive :
451- return p == target .getPrimitive ();
452- case kindWrapper :
453- return p == target .getWrapper ();
454- default :
455- return false ;
456- }
429+ return switch (kindOf (target )) {
430+ case kindPrimitive -> p == target .getPrimitive ();
431+ case kindWrapper -> p == target .getWrapper ();
432+ default -> false ;
433+ };
457434 }
458435
459436 /** isAssignable returns an updated type substitution mapping if t1 is assignable to t2. */
@@ -479,35 +456,22 @@ static Kind kindOf(Type t) {
479456 if (t == null || t .getTypeKindCase () == TypeKindCase .TYPEKIND_NOT_SET ) {
480457 return Kind .kindUnknown ;
481458 }
482- switch (t .getTypeKindCase ()) {
483- case ERROR :
484- return Kind .kindError ;
485- case FUNCTION :
486- return Kind .kindFunction ;
487- case DYN :
488- return Kind .kindDyn ;
489- case PRIMITIVE :
490- return Kind .kindPrimitive ;
491- case WELL_KNOWN :
492- return Kind .kindWellKnown ;
493- case WRAPPER :
494- return Kind .kindWrapper ;
495- case NULL :
496- return Kind .kindNull ;
497- case ABSTRACT_TYPE :
498- return Kind .kindAbstract ;
499- case TYPE :
500- return Kind .kindType ;
501- case LIST_TYPE :
502- return Kind .kindList ;
503- case MAP_TYPE :
504- return Kind .kindMap ;
505- case MESSAGE_TYPE :
506- return Kind .kindObject ;
507- case TYPE_PARAM :
508- return Kind .kindTypeParam ;
509- }
510- return Kind .kindUnknown ;
459+ return switch (t .getTypeKindCase ()) {
460+ case ERROR -> Kind .kindError ;
461+ case FUNCTION -> Kind .kindFunction ;
462+ case DYN -> Kind .kindDyn ;
463+ case PRIMITIVE -> Kind .kindPrimitive ;
464+ case WELL_KNOWN -> Kind .kindWellKnown ;
465+ case WRAPPER -> Kind .kindWrapper ;
466+ case NULL -> Kind .kindNull ;
467+ case ABSTRACT_TYPE -> Kind .kindAbstract ;
468+ case TYPE -> Kind .kindType ;
469+ case LIST_TYPE -> Kind .kindList ;
470+ case MAP_TYPE -> Kind .kindMap ;
471+ case MESSAGE_TYPE -> Kind .kindObject ;
472+ case TYPE_PARAM -> Kind .kindTypeParam ;
473+ default -> Kind .kindUnknown ;
474+ };
511475 }
512476
513477 /** mostGeneral returns the more general of two types which are known to unify. */
0 commit comments