diff --git a/infer/src/IR/AttributesTable.re b/infer/src/IR/AttributesTable.re
index 69fdc79b2..d58c40426 100644
--- a/infer/src/IR/AttributesTable.re
+++ b/infer/src/IR/AttributesTable.re
@@ -198,7 +198,7 @@ let load_defined_attributes cache_none::cache_none proc_name =>
     corresponds to the class definition. */
 let get_correct_type_from_objc_class_name type_name =>
   /* ToDo: this function should return a type that includes a reference to the tenv computed by:
-     let class_method = Typ.Procname.get_default_objc_class_method (Typename.name type_name);
+     let class_method = Typ.Procname.get_default_objc_class_method (Typ.Name.name type_name);
      switch (find_tenv_from_class_of_proc class_method) {
      | Some tenv =>
       */
diff --git a/infer/src/IR/AttributesTable.rei b/infer/src/IR/AttributesTable.rei
index fcdaa718e..73fc1479e 100644
--- a/infer/src/IR/AttributesTable.rei
+++ b/infer/src/IR/AttributesTable.rei
@@ -27,7 +27,7 @@ let load_defined_attributes: cache_none::bool => Typ.Procname.t => option ProcAt
 /** Given the name of an ObjC class, extract the type from the tenv where the class was defined. We
     do this by adding a method that is unique to each class, and then finding the tenv that
     corresponds to the class definition. */
-let get_correct_type_from_objc_class_name: Typename.t => option Typ.t;
+let get_correct_type_from_objc_class_name: Typ.Name.t => option Typ.t;
 
 /* Find the file where the procedure was captured, if a cfg for that file exists.
    Return also a boolean indicating whether the procedure is defined in an
diff --git a/infer/src/IR/BuiltinDecl.ml b/infer/src/IR/BuiltinDecl.ml
index 622fbbbad..14bf16cb0 100644
--- a/infer/src/IR/BuiltinDecl.ml
+++ b/infer/src/IR/BuiltinDecl.ml
@@ -23,7 +23,7 @@ let create_procname name =
 
 let create_objc_class_method class_name method_name =
   let method_kind = Typ.Procname.ObjCClassMethod in
-  let tname = Typename.Objc.from_string class_name in
+  let tname = Typ.Name.Objc.from_string class_name in
   let pname = Typ.Procname.ObjC_Cpp
       (Typ.Procname.objc_cpp tname method_name method_kind Typ.NoTemplate) in
   register pname;
diff --git a/infer/src/IR/Exceptions.ml b/infer/src/IR/Exceptions.ml
index 7677fad6b..a8ca3d1db 100644
--- a/infer/src/IR/Exceptions.ml
+++ b/infer/src/IR/Exceptions.ml
@@ -72,7 +72,7 @@ exception Frontend_warning of string * Localise.error_desc * L.ml_loc
 exception Checkers of string * Localise.error_desc
 exception Inherently_dangerous_function of Localise.error_desc
 exception Internal_error of Localise.error_desc
-exception Java_runtime_exception of Typename.t * string * Localise.error_desc
+exception Java_runtime_exception of Typ.Name.t * string * Localise.error_desc
 exception Leak of
     bool * Sil.hpred * (visibility * Localise.error_desc)
     * bool * PredSymb.resource * L.ml_loc
@@ -209,7 +209,7 @@ let recognize_exception exn =
         (Localise.from_string "Invalid_argument",
          desc, None, Exn_system, Low, None, Nocat)
     | Java_runtime_exception (exn_name, _, desc) ->
-        let exn_str = Typename.name exn_name in
+        let exn_str = Typ.Name.name exn_name in
         (Localise.from_string exn_str, desc, None, Exn_user, High, None, Prover)
     | Leak (fp_part, _, (exn_vis, error_desc), done_array_abstraction, resource, ml_loc) ->
         if done_array_abstraction
diff --git a/infer/src/IR/Exceptions.mli b/infer/src/IR/Exceptions.mli
index 0b9a6f0af..c126b0222 100644
--- a/infer/src/IR/Exceptions.mli
+++ b/infer/src/IR/Exceptions.mli
@@ -67,7 +67,7 @@ exception Checkers of string * Localise.error_desc
 exception Frontend_warning of string * Localise.error_desc * Logging.ml_loc
 exception Inherently_dangerous_function of Localise.error_desc
 exception Internal_error of Localise.error_desc
-exception Java_runtime_exception of Typename.t * string * Localise.error_desc
+exception Java_runtime_exception of Typ.Name.t * string * Localise.error_desc
 exception Leak of
     bool * Sil.hpred * (visibility * Localise.error_desc)
     * bool * PredSymb.resource * Logging.ml_loc
diff --git a/infer/src/IR/Localise.ml b/infer/src/IR/Localise.ml
index 0e5fde400..46528a444 100644
--- a/infer/src/IR/Localise.ml
+++ b/infer/src/IR/Localise.ml
@@ -304,7 +304,7 @@ let rec format_typ = function
   | Typ.Tptr (typ, _) when Config.curr_language_is Config.Java ->
       format_typ typ
   | Typ.Tstruct name ->
-      Typename.name name
+      Typ.Name.name name
   | typ ->
       Typ.to_string typ
 
@@ -465,7 +465,7 @@ let deref_str_uninitialized alloc_att_opt =
 let java_unchecked_exn_desc proc_name exn_name pre_str : error_desc =
   { no_desc with descriptions = [
         Typ.Procname.to_string proc_name;
-        "can throw " ^ (Typename.name exn_name);
+        "can throw " ^ (Typ.Name.name exn_name);
         "whenever " ^ pre_str];
   }
 
@@ -744,8 +744,8 @@ let desc_leak hpred_type_opt value_str_opt resource_opt resource_action_opt loc
           s, " to ", " on " in
     let typ_str =
       match hpred_type_opt with
-      | Some (Exp.Sizeof (Tstruct (TN_csu (Class _, _) as name), _, _)) ->
-          " of type " ^ Typename.name name ^ " "
+      | Some (Exp.Sizeof (Tstruct (TN_csu (Class _, _, _) as name), _, _)) ->
+          " of type " ^ Typ.Name.name name ^ " "
       | _ -> " " in
     let desc_str =
       match resource_opt with
diff --git a/infer/src/IR/Localise.mli b/infer/src/IR/Localise.mli
index b933ddb13..fe5c71331 100644
--- a/infer/src/IR/Localise.mli
+++ b/infer/src/IR/Localise.mli
@@ -249,7 +249,7 @@ val desc_buffer_overrun : string -> string -> error_desc
 
 val desc_null_test_after_dereference : string -> int -> Location.t -> error_desc
 
-val java_unchecked_exn_desc : Typ.Procname.t -> Typename.t -> string -> error_desc
+val java_unchecked_exn_desc : Typ.Procname.t -> Typ.Name.t -> string -> error_desc
 
 val desc_context_leak :
   Typ.Procname.t -> Typ.t -> Ident.fieldname ->
diff --git a/infer/src/IR/Objc_models.ml b/infer/src/IR/Objc_models.ml
index 479b2e250..692af2e32 100644
--- a/infer/src/IR/Objc_models.ml
+++ b/infer/src/IR/Objc_models.ml
@@ -210,7 +210,7 @@ struct
         is_core_lib lib styp
     | Typ.Tstruct name ->
         let core_lib_types = core_lib_to_type_list lib in
-        List.mem ~equal:String.equal core_lib_types (Typename.name name)
+        List.mem ~equal:String.equal core_lib_types (Typ.Name.name name)
     | _ -> false
 
   let is_core_foundation_type typ =
diff --git a/infer/src/IR/Subtype.re b/infer/src/IR/Subtype.re
index afd4ab71b..a0d090204 100644
--- a/infer/src/IR/Subtype.re
+++ b/infer/src/IR/Subtype.re
@@ -19,12 +19,12 @@ let list_to_string list =>
   if (Int.equal (List.length list) 0) {
     "( sub )"
   } else {
-    "- {" ^ String.concat sep::", " (List.map f::Typename.name list) ^ "}"
+    "- {" ^ String.concat sep::", " (List.map f::Typ.Name.name list) ^ "}"
   };
 
 type t' =
   | Exact /** denotes the current type only */
-  | Subtypes (list Typename.t)
+  | Subtypes (list Typ.Name.t)
 [@@deriving compare];
 
 let equal_modulo_flag (st1, _) (st2, _) => [%compare.equal : t'] st1 st2;
@@ -56,17 +56,16 @@ let max_result res1 res2 =>
     res1
   };
 
-let is_interface tenv (class_name: Typename.t) =>
+let is_interface tenv (class_name: Typ.Name.t) =>
   switch (class_name, Tenv.lookup tenv class_name) {
-  | (TN_csu (Class Java) _, Some {fields: [], methods: []}) => true
+  | (TN_csu (Class Java) _ _, Some {fields: [], methods: []}) => true
   | _ => false
   };
 
 let is_root_class class_name =>
   switch class_name {
-  | Typename.TN_csu (Csu.Class Csu.Java) _ =>
-    Typename.equal class_name Typename.Java.java_lang_object
-  | Typename.TN_csu (Csu.Class Csu.CPP) _ => false
+  | Typ.TN_csu (Csu.Class Csu.Java) _ _ => Typ.Name.equal class_name Typ.Name.Java.java_lang_object
+  | Typ.TN_csu (Csu.Class Csu.CPP) _ _ => false
   | _ => false
   };
 
@@ -85,7 +84,7 @@ let check_subclass_tenv tenv c1 c2 :result => {
       }
     }
   and check cn :result =>
-    if (Typename.equal cn c2) {
+    if (Typ.Name.equal cn c2) {
       Yes
     } else {
       switch (Tenv.lookup tenv cn) {
@@ -103,7 +102,7 @@ let check_subclass_tenv tenv c1 c2 :result => {
 
 let module SubtypesMap = Caml.Map.Make {
   /* pair of subtypes */
-  type t = (Typename.t, Typename.t) [@@deriving compare];
+  type t = (Typ.Name.t, Typ.Name.t) [@@deriving compare];
 };
 
 let check_subtype = {
@@ -168,7 +167,7 @@ let join (s1, flag1) (s2, flag2) => {
     switch (s1, s2) {
     | (Exact, _) => s2
     | (_, Exact) => s1
-    | (Subtypes l1, Subtypes l2) => Subtypes (list_intersect Typename.equal l1 l2)
+    | (Subtypes l1, Subtypes l2) => Subtypes (list_intersect Typ.Name.equal l1 l2)
     };
   let flag = join_flag flag1 flag2;
   (s, flag)
@@ -177,7 +176,7 @@ let join (s1, flag1) (s2, flag2) => {
 let update_flag c1 c2 flag flag' =>
   switch flag {
   | INSTOF =>
-    if (Typename.equal c1 c2) {
+    if (Typ.Name.equal c1 c2) {
       flag
     } else {
       flag'
@@ -205,7 +204,7 @@ let normalize_subtypes t_opt c1 c2 flag1 flag2 => {
   | Some t =>
     switch t {
     | Exact => Some (t, new_flag)
-    | Subtypes l => Some (Subtypes (List.sort cmp::Typename.compare l), new_flag)
+    | Subtypes l => Some (Subtypes (List.sort cmp::Typ.Name.compare l), new_flag)
     }
   | None => None
   }
@@ -220,7 +219,7 @@ let subtypes_to_string t =>
 /* c is a subtype when it does not appear in the list l of no-subtypes */
 let no_subtype_in_list tenv c l => not (List.exists f::(is_known_subtype tenv c) l);
 
-let is_strict_subtype tenv c1 c2 => is_known_subtype tenv c1 c2 && not (Typename.equal c1 c2);
+let is_strict_subtype tenv c1 c2 => is_known_subtype tenv c1 c2 && not (Typ.Name.equal c1 c2);
 
 /* checks for redundancies when adding c to l
    Xi in A - { X1,..., Xn } is redundant in two cases:
@@ -329,13 +328,13 @@ let case_analysis_basic tenv (c1, st) (c2, (_, flag2)) => {
     } else if (is_known_subtype tenv c2 c1) {
       switch st {
       | (Exact, _) =>
-        if (Typename.equal c1 c2) {
+        if (Typ.Name.equal c1 c2) {
           (Some st, None)
         } else {
           (None, Some st)
         }
       | (Subtypes _, _) =>
-        if (Typename.equal c1 c2) {
+        if (Typ.Name.equal c1 c2) {
           (Some st, None)
         } else {
           (Some st, Some st)
diff --git a/infer/src/IR/Subtype.rei b/infer/src/IR/Subtype.rei
index 8459e58f4..5ac8a9356 100644
--- a/infer/src/IR/Subtype.rei
+++ b/infer/src/IR/Subtype.rei
@@ -35,21 +35,21 @@ let join: t => t => t;
     [case_analysis] returns a pair:
     - whether [st1] and [st2] admit [c1 <: c2], and in case returns the updated subtype [st1]
     - whether [st1] and [st2] admit [not(c1 <: c2)], and in case returns the updated subtype [st1] */
-let case_analysis: Tenv.t => (Typename.t, t) => (Typename.t, t) => (option t, option t);
+let case_analysis: Tenv.t => (Typ.Name.t, t) => (Typ.Name.t, t) => (option t, option t);
 
 
 /** [is_known_subtype tenv c1 c2] returns true if there is enough information in [tenv] to prove
     that [c1] is a subtype of [c2].
     Note that [not (is_known_subtype tenv c1 c2) == true] does not imply
     that [is_known_not_subtype tenv c1 c2 == true] */
-let is_known_subtype: Tenv.t => Typename.t => Typename.t => bool;
+let is_known_subtype: Tenv.t => Typ.Name.t => Typ.Name.t => bool;
 
 
 /** [is_known_not_subtype tenv c1 c2] returns true if there is enough information in [tenv] to prove
     that [c1] is not a subtype of [c2].
     Note that [not (is_known_not_subtype tenv c1 c2) == true] does not imply
     that [is_known_subtype tenv c1 c2 == true] */
-let is_known_not_subtype: Tenv.t => Typename.t => Typename.t => bool;
+let is_known_not_subtype: Tenv.t => Typ.Name.t => Typ.Name.t => bool;
 
 let subtypes_to_string: t => string;
 
diff --git a/infer/src/IR/Tenv.re b/infer/src/IR/Tenv.re
index 3ba74efaa..14abfdb50 100644
--- a/infer/src/IR/Tenv.re
+++ b/infer/src/IR/Tenv.re
@@ -15,8 +15,8 @@ let module Hashtbl = Caml.Hashtbl;
 
 /** Hash tables on strings. */
 let module TypenameHash = Hashtbl.Make {
-  type t = Typename.t;
-  let equal tn1 tn2 => Typename.equal tn1 tn2;
+  type t = Typ.Name.t;
+  let equal tn1 tn2 => Typ.Name.equal tn1 tn2;
   let hash = Hashtbl.hash;
 };
 
@@ -28,7 +28,7 @@ let pp fmt (tenv: t) =>
   TypenameHash.iter
     (
       fun name typ => {
-        Format.fprintf fmt "@[<6>NAME: %s@." (Typename.to_string name);
+        Format.fprintf fmt "@[<6>NAME: %s@." (Typ.Name.to_string name);
         Format.fprintf fmt "@[<6>TYPE: %a@." (Typ.Struct.pp Pp.text name) typ
       }
     )
@@ -74,13 +74,13 @@ let lookup tenv name :option Typ.Struct.t =>
   try (Some (TypenameHash.find tenv name)) {
   | Not_found =>
     /* ToDo: remove the following additional lookups once C/C++ interop is resolved */
-    switch (name: Typename.t) {
-    | TN_csu Struct m =>
-      try (Some (TypenameHash.find tenv (TN_csu (Class CPP) m))) {
+    switch (name: Typ.Name.t) {
+    | TN_csu Struct m templ =>
+      try (Some (TypenameHash.find tenv (TN_csu (Class CPP) m templ))) {
       | Not_found => None
       }
-    | TN_csu (Class CPP) m =>
-      try (Some (TypenameHash.find tenv (TN_csu Struct m))) {
+    | TN_csu (Class CPP) m templ =>
+      try (Some (TypenameHash.find tenv (TN_csu Struct m templ))) {
       | Not_found => None
       }
     | _ => None
diff --git a/infer/src/IR/Tenv.rei b/infer/src/IR/Tenv.rei
index f1864c378..1c0c38eb0 100644
--- a/infer/src/IR/Tenv.rei
+++ b/infer/src/IR/Tenv.rei
@@ -14,7 +14,7 @@ type t; /** Type for type environment. */
 
 
 /** Add a (name,typename) pair to the global type environment. */
-let add: t => Typename.t => Typ.Struct.t => unit;
+let add: t => Typ.Name.t => Typ.Struct.t => unit;
 
 
 /** Create a new type environment. */
@@ -22,11 +22,11 @@ let create: unit => t;
 
 
 /** Fold a function over the elements of the type environment. */
-let fold: (Typename.t => Typ.Struct.t => 'a => 'a) => t => 'a => 'a;
+let fold: (Typ.Name.t => Typ.Struct.t => 'a => 'a) => t => 'a => 'a;
 
 
 /** iterate over a type environment */
-let iter: (Typename.t => Typ.Struct.t => unit) => t => unit;
+let iter: (Typ.Name.t => Typ.Struct.t => unit) => t => unit;
 
 
 /** Load a type environment from a file */
@@ -34,7 +34,7 @@ let load_from_file: DB.filename => option t;
 
 
 /** Look up a name in the global type environment. */
-let lookup: t => Typename.t => option Typ.Struct.t;
+let lookup: t => Typ.Name.t => option Typ.Struct.t;
 
 
 /** Construct a struct_typ, normalizing field types */
@@ -44,15 +44,15 @@ let mk_struct:
   fields::Typ.Struct.fields? =>
   statics::Typ.Struct.fields? =>
   methods::list Typ.Procname.t? =>
-  supers::list Typename.t? =>
+  supers::list Typ.Name.t? =>
   annots::Annot.Item.t? =>
   specialization::Typ.template_spec_info? =>
-  Typename.t =>
+  Typ.Name.t =>
   Typ.Struct.t;
 
 
 /** Check if typename is found in t */
-let mem: t => Typename.t => bool;
+let mem: t => Typ.Name.t => bool;
 
 
 /** print a type environment */
diff --git a/infer/src/IR/Typ.re b/infer/src/IR/Typ.re
index 9496fa84f..5d7df2e7c 100644
--- a/infer/src/IR/Typ.re
+++ b/infer/src/IR/Typ.re
@@ -131,8 +131,15 @@ let module T = {
     | Tvoid /** void type */
     | Tfun bool /** function type with noreturn attribute */
     | Tptr t ptr_kind /** pointer type */
-    | Tstruct Typename.t /** structured value type name */
+    | Tstruct name /** structured value type name */
     | Tarray t static_length /** array type with statically fixed length */
+  [@@deriving compare]
+  and name =
+    | TN_csu Csu.t Mangled.t template_spec_info
+  [@@deriving compare]
+  and template_spec_info =
+    | NoTemplate
+    | Template (string, list (option t))
   [@@deriving compare];
   let equal = [%compare.equal : t];
   let hash = Hashtbl.hash;
@@ -140,6 +147,57 @@ let module T = {
 
 include T;
 
+let module Name = {
+  type t = name [@@deriving compare];
+  let equal = [%compare.equal : t];
+  let to_string =
+    fun
+    | TN_csu csu name _ => Csu.name csu ^ " " ^ Mangled.to_string name;
+  let pp f typename => F.fprintf f "%s" (to_string typename);
+  let name =
+    fun
+    | TN_csu _ name _ => Mangled.to_string name;
+  let from_string_kind class_kind class_name_str =>
+    TN_csu (Csu.Class class_kind) (Mangled.from_string class_name_str) NoTemplate;
+  let is_class_kind class_kind =>
+    fun
+    | TN_csu (Class kind) _ _ when Csu.equal_class_kind class_kind kind => true
+    | _ => false;
+  let module C = {
+    let from_string name_str => TN_csu Csu.Struct (Mangled.from_string name_str) NoTemplate;
+    let union_from_string name_str => TN_csu Csu.Union (Mangled.from_string name_str) NoTemplate;
+  };
+  let module Java = {
+    let from_string = from_string_kind Csu.Java;
+    let from_package_class package_name class_name =>
+      if (String.equal package_name "") {
+        from_string class_name
+      } else {
+        from_string (package_name ^ "." ^ class_name)
+      };
+    let is_class = is_class_kind Csu.Java;
+    let java_lang_object = from_string "java.lang.Object";
+    let java_io_serializable = from_string "java.io.Serializable";
+    let java_lang_cloneable = from_string "java.lang.Cloneable";
+  };
+  let module Cpp = {
+    let from_string = from_string_kind Csu.CPP;
+    let from_template_string template_spec_info name =>
+      TN_csu (Csu.Class Csu.CPP) (Mangled.from_string name) template_spec_info;
+    let is_class = is_class_kind Csu.CPP;
+  };
+  let module Objc = {
+    let from_string = from_string_kind Csu.Objc;
+    let protocol_from_string name_str =>
+      TN_csu Csu.Protocol (Mangled.from_string name_str) NoTemplate;
+    let is_class = is_class_kind Csu.Objc;
+  };
+  let module Set = Caml.Set.Make {
+    type nonrec t = t;
+    let compare = compare;
+  };
+};
+
 
 /** {2 Sets and maps of types} */
 let module Set = Caml.Set.Make T;
@@ -163,9 +221,9 @@ let rec pp_full pe f =>
   fun
   | Tstruct tname =>
     if (Pp.equal_print_kind pe.Pp.kind Pp.HTML) {
-      F.fprintf f "%s" (Typename.to_string tname |> Escape.escape_xml)
+      F.fprintf f "%s" (Name.to_string tname |> Escape.escape_xml)
     } else {
-      F.fprintf f "%s" (Typename.to_string tname)
+      F.fprintf f "%s" (Name.to_string tname)
     }
   | Tint ik => F.fprintf f "%s" (ikind_to_string ik)
   | Tfloat fk => F.fprintf f "%s" (fkind_to_string fk)
@@ -236,7 +294,7 @@ let array_elem default_opt =>
 
 let is_class_of_kind typ ck =>
   switch typ {
-  | Tstruct (TN_csu (Class ck') _) => Csu.equal_class_kind ck ck'
+  | Tstruct (TN_csu (Class ck') _ _) => Csu.equal_class_kind ck ck'
   | _ => false
   };
 
@@ -286,16 +344,10 @@ let rec java_from_string =
       let stripped_typ = String.sub typ_str pos::0 len::(String.length typ_str - 2);
       Tptr (Tarray (java_from_string stripped_typ) None) Pk_pointer
     }
-  | typ_str => Tstruct (Typename.Java.from_string typ_str);
+  | typ_str => Tstruct (Name.Java.from_string typ_str);
 
 type typ = t [@@deriving compare];
 
-/* template instantiation arguments */
-type template_spec_info =
-  | NoTemplate
-  | Template (string, list (option t))
-[@@deriving compare];
-
 let module Procname = {
   /* e.g. ("", "int") for primitive types or ("java.io", "PrintWriter") for objects */
   type java_type = (option string, string);
@@ -312,7 +364,7 @@ let module Procname = {
   type java = {
     method_name: string,
     parameters: list java_type,
-    class_name: Typename.t,
+    class_name: Name.t,
     return_type: option java_type, /* option because constructors have no return type */
     kind: method_kind
   }
@@ -332,7 +384,7 @@ let module Procname = {
   /** Type of Objective C and C++ procedure names: method signatures. */
   type objc_cpp = {
     method_name: string,
-    class_name: Typename.t,
+    class_name: Name.t,
     kind: objc_cpp_method_kind,
     template_args: template_spec_info
   }
@@ -403,7 +455,7 @@ let module Procname = {
     | Some (x, y) => (Some x, y)
     | None => (None, package_classname)
     };
-  let split_typename typename => split_classname (Typename.name typename);
+  let split_typename typename => split_classname (Name.name typename);
   let c (name: string) (mangled: string) (template_args: template_spec_info) => {
     name,
     mangled: Some mangled,
@@ -447,7 +499,7 @@ let module Procname = {
 
   /** Replace the class name component of a procedure name.
       In case of Java, replace package and class name. */
-  let replace_class t (new_class: Typename.t) =>
+  let replace_class t (new_class: Name.t) =>
     switch t {
     | Java j => Java {...j, class_name: new_class}
     | ObjC_Cpp osig => ObjC_Cpp {...osig, class_name: new_class}
@@ -457,11 +509,11 @@ let module Procname = {
     };
 
   /** Get the class name of a Objective-C/C++ procedure name. */
-  let objc_cpp_get_class_name objc_cpp => Typename.name objc_cpp.class_name;
+  let objc_cpp_get_class_name objc_cpp => Name.name objc_cpp.class_name;
   let objc_cpp_get_class_type_name objc_cpp => objc_cpp.class_name;
 
   /** Return the package.classname of a java procname. */
-  let java_get_class_name (j: java) => Typename.name j.class_name;
+  let java_get_class_name (j: java) => Name.name j.class_name;
 
   /** Return the package.classname as a typename of a java procname. */
   let java_get_class_type_name (j: java) => j.class_name;
@@ -594,7 +646,7 @@ let module Procname = {
     | Java js =>
       switch (List.rev js.parameters) {
       | [(_, s), ...par'] =>
-        if (is_anonymous_inner_class_name (Typename.Java.from_string s)) {
+        if (is_anonymous_inner_class_name (Name.Java.from_string s)) {
           Some (Java {...js, parameters: List.rev par'})
         } else {
           None
@@ -735,10 +787,10 @@ let module Procname = {
   let c_method_to_string osig detail_level =>
     switch detail_level {
     | Simple => osig.method_name
-    | Non_verbose => Typename.name osig.class_name ^ "_" ^ osig.method_name
+    | Non_verbose => Name.name osig.class_name ^ "_" ^ osig.method_name
     | Verbose =>
       let m_str = c_method_kind_verbose_str osig.kind;
-      Typename.name osig.class_name ^ "_" ^ osig.method_name ^ m_str
+      Name.name osig.class_name ^ "_" ^ osig.method_name ^ m_str
     };
 
   /** Very verbose representation of an existing Procname.t */
@@ -797,7 +849,7 @@ let module Procname = {
     | C {name} => QualifiedCppName.qualifiers_of_qual_name name
     | ObjC_Cpp objc_cpp =>
       List.append
-        (QualifiedCppName.qualifiers_of_qual_name (Typename.name objc_cpp.class_name))
+        (QualifiedCppName.qualifiers_of_qual_name (Name.name objc_cpp.class_name))
         [objc_cpp.method_name]
     | _ => []
     };
@@ -834,19 +886,19 @@ let module Struct = {
   type t = {
     fields: fields, /** non-static fields */
     statics: fields, /** static fields */
-    supers: list Typename.t, /** superclasses */
+    supers: list Name.t, /** superclasses */
     methods: list Procname.t, /** methods defined */
     annots: Annot.Item.t, /** annotations */
     specialization: template_spec_info /** template specialization */
   };
-  type lookup = Typename.t => option t;
+  type lookup = Name.t => option t;
   let pp pe name f {fields, supers, methods, annots} =>
     if Config.debug_mode {
       /* change false to true to print the details of struct */
       F.fprintf
         f
         "%a \n\tfields: {%a\n\t}\n\tsupers: {%a\n\t}\n\tmethods: {%a\n\t}\n\tannots: {%a\n\t}"
-        Typename.pp
+        Name.pp
         name
         (
           Pp.seq (
@@ -855,14 +907,14 @@ let module Struct = {
           )
         )
         fields
-        (Pp.seq (fun f n => F.fprintf f "\n\t\t%a" Typename.pp n))
+        (Pp.seq (fun f n => F.fprintf f "\n\t\t%a" Name.pp n))
         supers
         (Pp.seq (fun f m => F.fprintf f "\n\t\t%a" Procname.pp m))
         methods
         Annot.Item.pp
         annots
     } else {
-      F.fprintf f "%a" Typename.pp name
+      F.fprintf f "%a" Name.pp name
     };
   let internal_mk_struct
       default::default=?
diff --git a/infer/src/IR/Typ.rei b/infer/src/IR/Typ.rei
index 614990cf8..d980c9962 100644
--- a/infer/src/IR/Typ.rei
+++ b/infer/src/IR/Typ.rei
@@ -77,10 +77,67 @@ type t =
   | Tvoid /** void type */
   | Tfun bool /** function type with noreturn attribute */
   | Tptr t ptr_kind /** pointer type */
-  | Tstruct Typename.t /** structured value type name */
+  | Tstruct name /** structured value type name */
   | Tarray t static_length /** array type with statically fixed length */
+[@@deriving compare]
+and name =
+  | TN_csu Csu.t Mangled.t template_spec_info
+[@@deriving compare]
+and template_spec_info =
+  | NoTemplate
+  | Template (string, list (option t))
 [@@deriving compare];
 
+let module Name: {
+
+  /** Named types. */
+  type t = name [@@deriving compare];
+
+  /** Equality for typenames */
+  let equal: t => t => bool;
+
+  /** convert the typename to a string */
+  let to_string: t => string;
+  let pp: Format.formatter => t => unit;
+
+  /** name of the typename without qualifier */
+  let name: t => string;
+  let module C: {let from_string: string => t; let union_from_string: string => t;};
+  let module Java: {
+
+    /** Create a typename from a Java classname in the form "package.class" */
+    let from_string: string => t;
+
+    /** Create a typename from a package name and a class name */
+    let from_package_class: string => string => t;
+
+    /** [is_class name] holds if [name] names a Java class */
+    let is_class: t => bool;
+    let java_lang_object: t;
+    let java_io_serializable: t;
+    let java_lang_cloneable: t;
+  };
+  let module Cpp: {
+
+    /** Create a typename from a C++ classname */
+    let from_string: string => t;
+    let from_template_string: template_spec_info => string => t;
+
+    /** [is_class name] holds if [name] names a C++ class */
+    let is_class: t => bool;
+  };
+  let module Objc: {
+
+    /** Create a typename from a Objc classname */
+    let from_string: string => t;
+    let protocol_from_string: string => t;
+
+    /** [is_class name] holds if [name] names a Objc class */
+    let is_class: t => bool;
+  };
+  let module Set: Caml.Set.S with type elt = t;
+};
+
 
 /** Equality for types. */
 let equal: t => t => bool;
@@ -119,7 +176,7 @@ let d_list: list t => unit;
 
 
 /** The name of a type */
-let name: t => option Typename.t;
+let name: t => option Name.t;
 
 
 /** turn a *T into a T. fails if [t] is not a pointer type */
@@ -150,12 +207,6 @@ let unsome: string => option t => t;
 
 type typ = t;
 
-/* template instantiation arguments */
-type template_spec_info =
-  | NoTemplate
-  | Template (string, list (option t))
-[@@deriving compare];
-
 let module Procname: {
 
   /** Module for Procedure Names. */
@@ -222,7 +273,7 @@ let module Procname: {
   let hash_pname: t => int;
 
   /** Check if a class string is an anoynmous inner class name. */
-  let is_anonymous_inner_class_name: Typename.t => bool;
+  let is_anonymous_inner_class_name: Name.t => bool;
 
   /** Check if this is an Objective-C/C++ method name. */
   let is_c_method: t => bool;
@@ -247,7 +298,7 @@ let module Procname: {
 
   /** Create a Java procedure name from its
       class_name method_name args_type_name return_type_name method_kind. */
-  let java: Typename.t => option java_type => string => list java_type => method_kind => java;
+  let java: Name.t => option java_type => string => list java_type => method_kind => java;
 
   /** Replace the parameters of a java procname. */
   let java_replace_parameters: java => list java_type => java;
@@ -259,12 +310,12 @@ let module Procname: {
   let mangled_objc_block: string => t;
 
   /** Create an objc procedure name from a class_name and method_name. */
-  let objc_cpp: Typename.t => string => objc_cpp_method_kind => template_spec_info => objc_cpp;
-  let get_default_objc_class_method: Typename.t => t;
+  let objc_cpp: Name.t => string => objc_cpp_method_kind => template_spec_info => objc_cpp;
+  let get_default_objc_class_method: Name.t => t;
 
   /** Get the class name of a Objective-C/C++ procedure name. */
   let objc_cpp_get_class_name: objc_cpp => string;
-  let objc_cpp_get_class_type_name: objc_cpp => Typename.t;
+  let objc_cpp_get_class_type_name: objc_cpp => Name.t;
 
   /** Create ObjC method type from a bool is_instance. */
   let objc_method_kind_of_bool: bool => objc_cpp_method_kind;
@@ -273,7 +324,7 @@ let module Procname: {
   let java_get_class_name: java => string;
 
   /** Return the class name as a typename of a java procedure name. */
-  let java_get_class_type_name: java => Typename.t;
+  let java_get_class_type_name: java => Name.t;
 
   /** Return the simple class name of a java procedure name. */
   let java_get_simple_class_name: java => string;
@@ -345,7 +396,7 @@ let module Procname: {
 
   /** Replace the class name component of a procedure name.
       In case of Java, replace package and class name. */
-  let replace_class: t => Typename.t => t;
+  let replace_class: t => Name.t => t;
 
   /** Given a package.class_name string, look for the latest dot and split the string
       in two (package, class_name). */
@@ -377,15 +428,15 @@ let module Struct: {
   type t = private {
     fields: fields, /** non-static fields */
     statics: fields, /** static fields */
-    supers: list Typename.t, /** supers */
+    supers: list Name.t, /** supers */
     methods: list Procname.t, /** methods defined */
     annots: Annot.Item.t, /** annotations */
     specialization: template_spec_info /** template specialization */
   };
-  type lookup = Typename.t => option t;
+  type lookup = Name.t => option t;
 
   /** Pretty print a struct type. */
-  let pp: Pp.env => Typename.t => F.formatter => t => unit;
+  let pp: Pp.env => Name.t => F.formatter => t => unit;
 
   /** Construct a struct_typ, normalizing field types */
   let internal_mk_struct:
@@ -393,7 +444,7 @@ let module Struct: {
     fields::fields? =>
     statics::fields? =>
     methods::list Procname.t? =>
-    supers::list Typename.t? =>
+    supers::list Name.t? =>
     annots::Annot.Item.t? =>
     specialization::template_spec_info? =>
     unit =>
diff --git a/infer/src/backend/BuiltinDefn.ml b/infer/src/backend/BuiltinDefn.ml
index 146b69817..ebda078ae 100644
--- a/infer/src/backend/BuiltinDefn.ml
+++ b/infer/src/backend/BuiltinDefn.ml
@@ -756,7 +756,7 @@ let execute_alloc mk can_return_null
         evaluate_char_sizeof (Exp.Const (Const.Cint len))
     | Exp.Sizeof _ -> e in
   let size_exp, procname = match args with
-    | [(Exp.Sizeof (Tstruct (TN_csu (Class Objc, _) as name) as s, len, subt), _)] ->
+    | [(Exp.Sizeof (Tstruct (TN_csu (Class Objc, _, _) as name) as s, len, subt), _)] ->
         let struct_type =
           match AttributesTable.get_correct_type_from_objc_class_name name with
           | Some struct_type -> struct_type
diff --git a/infer/src/backend/paths.ml b/infer/src/backend/paths.ml
index 173388ed0..528213ab5 100644
--- a/infer/src/backend/paths.ml
+++ b/infer/src/backend/paths.ml
@@ -45,7 +45,7 @@ module Path : sig
   val d_stats : t -> unit
 
   (** extend a path with a new node reached from the given session, with an optional string for exceptions *)
-  val extend : Procdesc.Node.t -> Typename.t option -> session -> t -> t
+  val extend : Procdesc.Node.t -> Typ.Name.t option -> session -> t -> t
 
   (** extend a path with a new node reached from the given session, with an optional string for exceptions *)
   val add_description : t -> string -> t
@@ -54,7 +54,7 @@ module Path : sig
   val iter_all_nodes_nocalls : (Procdesc.Node.t -> unit) -> t -> unit
 
   val iter_shortest_sequence :
-    (int -> t -> int -> Typename.t option -> unit) -> PredSymb.path_pos option -> t -> unit
+    (int -> t -> int -> Typ.Name.t option -> unit) -> PredSymb.path_pos option -> t -> unit
 
   (** join two paths *)
   val join : t -> t -> t
@@ -94,7 +94,7 @@ end = struct
     (* INVARIANT: stats are always set to dummy_stats unless we are in the middle of a traversal *)
     (* in particular: a new traversal cannot be initiated during an existing traversal *)
     | Pstart of Procdesc.Node.t * _stats (** start node *)
-    | Pnode of Procdesc.Node.t * Typename.t option * session * t * _stats * _string_option
+    | Pnode of Procdesc.Node.t * Typ.Name.t option * session * t * _stats * _string_option
     (** we got to [node] from last [session] perhaps propagating exception [exn_opt],
         and continue with [path].  *)
     | Pjoin of t * t * _stats (** join of two paths *)
@@ -267,7 +267,7 @@ end = struct
       If a node is reached via an exception,
       pass the exception information to [f] on the previous node *)
   let iter_shortest_sequence_filter
-      (f : int -> t -> int -> Typename.t option -> unit)
+      (f : int -> t -> int -> Typ.Name.t option -> unit)
       (filter: Procdesc.Node.t -> bool) (path: t) : unit =
     let rec doit level session path prev_exn_opt = match path with
       | Pstart _ -> f level path session prev_exn_opt
@@ -295,7 +295,7 @@ end = struct
       [f level path session exn_opt] is passed the current nesting [level] and [path]
       and previous [session] and possible exception [exn_opt] *)
   let iter_shortest_sequence
-      (f : int -> t -> int -> Typename.t option -> unit)
+      (f : int -> t -> int -> Typ.Name.t option -> unit)
       (pos_opt : PredSymb.path_pos option) (path: t) : unit =
     let filter node = match pos_opt with
       | None -> true
@@ -472,7 +472,7 @@ end = struct
                   match exn_opt with
                   | None -> "", []
                   | Some exn_name ->
-                      let exn_str = Typename.name exn_name in
+                      let exn_str = Typ.Name.name exn_name in
                       if String.equal exn_str ""
                       then "exception", [(Io_infer.Xml.tag_kind,"exception")]
                       else
diff --git a/infer/src/backend/paths.mli b/infer/src/backend/paths.mli
index 92ab00942..4ecc54b21 100644
--- a/infer/src/backend/paths.mli
+++ b/infer/src/backend/paths.mli
@@ -40,7 +40,7 @@ module Path : sig
   val d_stats : t -> unit
 
   (** extend a path with a new node reached from the given session, with an optional string for exceptions *)
-  val extend : Procdesc.Node.t -> Typename.t option -> session -> t -> t
+  val extend : Procdesc.Node.t -> Typ.Name.t option -> session -> t -> t
 
   val add_description : t -> string -> t
 
@@ -53,7 +53,7 @@ module Path : sig
       [f level path session exn_opt] is passed the current nesting [level] and [path]
       and previous [session] and possible exception [exn_opt] *)
   val iter_shortest_sequence :
-    (int -> t -> int -> Typename.t option -> unit) -> PredSymb.path_pos option -> t -> unit
+    (int -> t -> int -> Typ.Name.t option -> unit) -> PredSymb.path_pos option -> t -> unit
 
   (** join two paths *)
   val join : t -> t -> t
diff --git a/infer/src/backend/prover.ml b/infer/src/backend/prover.ml
index ce631b0e0..3db263607 100644
--- a/infer/src/backend/prover.ml
+++ b/infer/src/backend/prover.ml
@@ -38,7 +38,7 @@ let rec remove_redundancy have_same_key acc = function
 
 let rec is_java_class tenv (typ: Typ.t) =
   match typ with
-  | Tstruct name -> Typename.Java.is_class name
+  | Tstruct name -> Typ.Name.Java.is_class name
   | Tarray (inner_typ, _) | Tptr (inner_typ, _) -> is_java_class tenv inner_typ
   | _ -> false
 
@@ -1506,7 +1506,7 @@ let expand_hpred_pointer =
                 | Sizeof (cnt_typ, len, st) ->
                     (* type of struct at adr_base is unknown (typically Tvoid), but
                        type of contents is known, so construct struct type for single fld:cnt_typ *)
-                    let name = Typename.C.from_string ("counterfeit" ^ string_of_int !count) in
+                    let name = Typ.Name.C.from_string ("counterfeit" ^ string_of_int !count) in
                     incr count ;
                     let fields = [(fld, cnt_typ, Annot.Item.empty)] in
                     ignore (Tenv.mk_struct tenv ~fields name) ;
@@ -1549,16 +1549,16 @@ struct
   (** check if t1 is a subtype of t2, in Java *)
   let rec check_subtype_java tenv (t1: Typ.t) (t2: Typ.t) =
     match t1, t2 with
-    | Tstruct (TN_csu (Class Java, _) as cn1), Tstruct (TN_csu (Class Java, _) as cn2) ->
+    | Tstruct (TN_csu (Class Java, _, _) as cn1), Tstruct (TN_csu (Class Java, _, _) as cn2) ->
         Subtype.is_known_subtype tenv cn1 cn2
     | Tarray (dom_type1, _), Tarray (dom_type2, _) ->
         check_subtype_java tenv dom_type1 dom_type2
     | Tptr (dom_type1, _), Tptr (dom_type2, _) ->
         check_subtype_java tenv dom_type1 dom_type2
-    | Tarray _, Tstruct (TN_csu (Class Java, _) as cn2) ->
-        Typename.equal cn2 Typename.Java.java_io_serializable
-        || Typename.equal cn2 Typename.Java.java_lang_cloneable
-        || Typename.equal cn2 Typename.Java.java_lang_object
+    | Tarray _, Tstruct (TN_csu (Class Java, _, _) as cn2) ->
+        Typ.Name.equal cn2 Typ.Name.Java.java_io_serializable
+        || Typ.Name.equal cn2 Typ.Name.Java.java_lang_cloneable
+        || Typ.Name.equal cn2 Typ.Name.Java.java_lang_object
     | _ -> check_subtype_basic_type t1 t2
 
   (** check if t1 is a subtype of t2 *)
@@ -1573,12 +1573,12 @@ struct
 
   let rec case_analysis_type tenv ((t1: Typ.t), st1) ((t2: Typ.t), st2) =
     match t1, t2 with
-    | Tstruct (TN_csu (Class Java, _) as cn1), Tstruct (TN_csu (Class Java, _) as cn2) ->
+    | Tstruct (TN_csu (Class Java, _, _) as cn1), Tstruct (TN_csu (Class Java, _, _) as cn2) ->
         Subtype.case_analysis tenv (cn1, st1) (cn2, st2)
-    | Tstruct (TN_csu (Class Java, _) as cn1), Tarray _
-      when (Typename.equal cn1 Typename.Java.java_io_serializable
-            || Typename.equal cn1 Typename.Java.java_lang_cloneable
-            || Typename.equal cn1 Typename.Java.java_lang_object) &&
+    | Tstruct (TN_csu (Class Java, _, _) as cn1), Tarray _
+      when (Typ.Name.equal cn1 Typ.Name.Java.java_io_serializable
+            || Typ.Name.equal cn1 Typ.Name.Java.java_lang_cloneable
+            || Typ.Name.equal cn1 Typ.Name.Java.java_lang_object) &&
            st1 <> Subtype.exact ->
         Some st1, None
     | Tstruct cn1, Tstruct cn2
@@ -1982,7 +1982,7 @@ and sigma_imply tenv calc_index_frame calc_missing subs prop1 sigma2 : (subst2 *
       | Config.Clang ->
           Exp.Sizeof (Typ.Tarray (Typ.Tint Typ.IChar, Some len), None, Subtype.exact)
       | Config.Java ->
-          let object_type = Typename.Java.from_string "java.lang.String" in
+          let object_type = Typ.Name.Java.from_string "java.lang.String" in
           Exp.Sizeof (Tstruct object_type, None, Subtype.exact) in
     Sil.Hpointsto (root, sexp, const_string_texp) in
   let mk_constant_class_hpred s = (* creat an hpred from a constant class *)
@@ -1992,7 +1992,7 @@ and sigma_imply tenv calc_index_frame calc_missing subs prop1 sigma2 : (subst2 *
         ([(Ident.create_fieldname (Mangled.from_string "java.lang.Class.name") 0,
            Sil.Eexp ((Exp.Const (Const.Cstr s), Sil.Inone)))], Sil.inst_none) in
     let class_texp =
-      let class_type = Typename.Java.from_string "java.lang.Class" in
+      let class_type = Typ.Name.Java.from_string "java.lang.Class" in
       Exp.Sizeof (Tstruct class_type, None, Subtype.exact) in
     Sil.Hpointsto (root, sexp, class_texp) in
   try
diff --git a/infer/src/backend/rearrange.ml b/infer/src/backend/rearrange.ml
index 3a6e270d7..4407f1967 100644
--- a/infer/src/backend/rearrange.ml
+++ b/infer/src/backend/rearrange.ml
@@ -668,7 +668,7 @@ let add_guarded_by_constraints tenv prop lexp pdesc =
     | Typ.Procname.Java java_pname ->
         let current_class_type_name = (Typ.Procname.java_get_class_type_name java_pname) in
         let comparison class_type_name _ =
-          guarded_by_str_is_class_this (Typename.to_string class_type_name) guarded_by_str in
+          guarded_by_str_is_class_this (Typ.Name.to_string class_type_name) guarded_by_str in
         PatternMatch.supertype_exists tenv comparison current_class_type_name
     | _ -> false in
 
@@ -815,7 +815,7 @@ let add_guarded_by_constraints tenv prop lexp pdesc =
       let str_is_read_write_lock str = String.is_suffix ~suffix:"ReadWriteUpdateLock" str ||
                                        String.is_suffix ~suffix:"ReadWriteLock" str  in
       match typ with
-      | Typ.Tstruct name -> str_is_read_write_lock (Typename.name name)
+      | Typ.Tstruct name -> str_is_read_write_lock (Typ.Name.name name)
       | Typ.Tptr (typ, _) -> is_read_write_lock typ
       | _ -> false in
     let has_lock guarded_by_exp =
diff --git a/infer/src/backend/symExec.ml b/infer/src/backend/symExec.ml
index 850a564fc..0415680f8 100644
--- a/infer/src/backend/symExec.ml
+++ b/infer/src/backend/symExec.ml
@@ -482,19 +482,19 @@ let method_exists right_proc_name methods =
 
 let resolve_method tenv class_name proc_name =
   let found_class =
-    let visited = ref Typename.Set.empty in
-    let rec resolve (class_name: Typename.t) =
-      visited := Typename.Set.add class_name !visited;
+    let visited = ref Typ.Name.Set.empty in
+    let rec resolve (class_name: Typ.Name.t) =
+      visited := Typ.Name.Set.add class_name !visited;
       let right_proc_name =
         Typ.Procname.replace_class proc_name class_name in
       match class_name, Tenv.lookup tenv class_name with
-      | TN_csu (Class _, _), Some { methods; supers } ->
+      | TN_csu (Class _, _, _), Some { methods; supers } ->
           if method_exists right_proc_name methods then
             Some right_proc_name
           else
             (match supers with
              | super_classname:: _ ->
-                 if not (Typename.Set.mem super_classname !visited)
+                 if not (Typ.Name.Set.mem super_classname !visited)
                  then resolve super_classname
                  else None
              | _ -> None)
@@ -503,7 +503,7 @@ let resolve_method tenv class_name proc_name =
   match found_class with
   | None ->
       Logging.d_strln
-        ("Couldn't find method in the hierarchy of type "^(Typename.name class_name));
+        ("Couldn't find method in the hierarchy of type "^(Typ.Name.name class_name));
       proc_name
   | Some proc_name ->
       proc_name
@@ -601,7 +601,7 @@ let resolve_java_pname tenv prop args pname_java call_flags : Typ.Procname.java
           ~f:(fun accu (arg_exp, _) name ->
               match resolve_typename prop arg_exp with
               | Some class_name ->
-                  (Typ.Procname.split_classname (Typename.name class_name)) :: accu
+                  (Typ.Procname.split_classname (Typ.Name.name class_name)) :: accu
               | None -> name :: accu)
           ~init:[] args (Typ.Procname.java_get_parameters resolved_pname_java) |> List.rev in
       Typ.Procname.java_replace_parameters resolved_pname_java resolved_params in
@@ -670,7 +670,7 @@ let call_constructor_url_update_args pname actual_params =
   let url_pname =
     Typ.Procname.Java
       (Typ.Procname.java
-         (Typename.Java.from_string "java.net.URL") None "<init>"
+         (Typ.Name.Java.from_string "java.net.URL") None "<init>"
          [(Some "java.lang"), "String"] Typ.Procname.Non_Static) in
   if (Typ.Procname.equal url_pname pname) then
     (match actual_params with
diff --git a/infer/src/backend/symExec.mli b/infer/src/backend/symExec.mli
index af2300d44..146567fdd 100644
--- a/infer/src/backend/symExec.mli
+++ b/infer/src/backend/symExec.mli
@@ -45,4 +45,4 @@ val prune : Tenv.t -> positive:bool -> Exp.t -> Prop.normal Prop.t -> Propset.t
     the procname that the method name will actually resolve to at runtime. For example, if we have a
     procname like Foo.toString() and Foo does not override toString(), we must resolve the call to
     toString(). We will end up with Super.toString() where Super is some superclass of Foo. *)
-val resolve_method : Tenv.t -> Typename.t -> Typ.Procname.t -> Typ.Procname.t
+val resolve_method : Tenv.t -> Typ.Name.t -> Typ.Procname.t -> Typ.Procname.t
diff --git a/infer/src/backend/tabulation.ml b/infer/src/backend/tabulation.ml
index c19680e68..40ff95132 100644
--- a/infer/src/backend/tabulation.ml
+++ b/infer/src/backend/tabulation.ml
@@ -471,7 +471,7 @@ let texp_star tenv texp1 texp2 =
           | _ -> ftal_sub ftal1 ftal2' end in
   let typ_star (t1: Typ.t) (t2: Typ.t) =
     match t1, t2 with
-    | Tstruct (TN_csu (csu1, _) as name1), Tstruct (TN_csu (csu2, _) as name2)
+    | Tstruct (TN_csu (csu1, _, _) as name1), Tstruct (TN_csu (csu2, _, _) as name2)
       when Csu.equal csu1 csu2 -> (
         match Tenv.lookup tenv name1, Tenv.lookup tenv name2 with
         | Some { fields = fields1 }, Some { fields = fields2 } when ftal_sub fields1 fields2 ->
diff --git a/infer/src/backend/tabulation.mli b/infer/src/backend/tabulation.mli
index 5926eef03..9b3e76fd4 100644
--- a/infer/src/backend/tabulation.mli
+++ b/infer/src/backend/tabulation.mli
@@ -34,7 +34,7 @@ val create_cast_exception :
 val prop_is_exn : Typ.Procname.t -> 'a Prop.t -> bool
 
 (** when prop is an exception, return the exception name *)
-val prop_get_exn_name : Typ.Procname.t -> 'a Prop.t -> Typename.t option
+val prop_get_exn_name : Typ.Procname.t -> 'a Prop.t -> Typ.Name.t option
 
 (** search in prop contains an error state *)
 val lookup_custom_errors : 'a Prop.t -> string option
diff --git a/infer/src/backend/taint.ml b/infer/src/backend/taint.ml
index 1dcf46790..134810da4 100644
--- a/infer/src/backend/taint.ml
+++ b/infer/src/backend/taint.ml
@@ -264,7 +264,7 @@ let functions_with_tainted_params = [
 let java_method_to_procname java_method =
   Typ.Procname.Java
     (Typ.Procname.java
-       (Typename.Java.from_string java_method.classname)
+       (Typ.Name.Java.from_string java_method.classname)
        (Some (Typ.Procname.split_classname java_method.ret_type))
        java_method.method_name
        (List.map ~f:Typ.Procname.split_classname java_method.params)
@@ -273,7 +273,7 @@ let java_method_to_procname java_method =
 (* turn string specificiation of an objc method into a procname *)
 let objc_method_to_procname objc_method =
   let method_kind = Typ.Procname.objc_method_kind_of_bool (not objc_method.is_static) in
-  let typename = Typename.Objc.from_string objc_method.classname in
+  let typename = Typ.Name.Objc.from_string objc_method.classname in
   Typ.Procname.ObjC_Cpp
     (Typ.Procname.objc_cpp typename objc_method.method_name method_kind Typ.NoTemplate)
 
diff --git a/infer/src/checkers/ThreadSafety.ml b/infer/src/checkers/ThreadSafety.ml
index 866ca26b1..5dcbdb702 100644
--- a/infer/src/checkers/ThreadSafety.ml
+++ b/infer/src/checkers/ThreadSafety.ml
@@ -341,13 +341,13 @@ module TransferFunctions (CFG : ProcCfg.S) = struct
   let exec_instr (astate : Domain.astate) ({ ProcData.pdesc; tenv; extras; } as proc_data) _ =
     let is_container_write pn tenv = match pn with
       | Typ.Procname.Java java_pname ->
-          let typename = Typename.Java.from_string (Typ.Procname.java_get_class_name java_pname) in
+          let typename = Typ.Name.Java.from_string (Typ.Procname.java_get_class_name java_pname) in
           let is_container_write_ typename _ =
-            match Typename.name typename, Typ.Procname.java_get_method java_pname with
+            match Typ.Name.name typename, Typ.Procname.java_get_method java_pname with
             | "java.util.List", ("add" | "addAll" | "clear" | "remove" | "set") -> true
             | "java.util.Map", ("clear" | "put" | "putAll" | "remove") -> true
             | _ -> false in
-          let is_threadsafe_collection typename _ = match Typename.name typename with
+          let is_threadsafe_collection typename _ = match Typ.Name.name typename with
             | "java.util.concurrent.ConcurrentMap" | "java.util.concurrent.CopyOnWriteArrayList" ->
                 true
             | _ ->
@@ -750,7 +750,7 @@ let is_immutable_collection_class class_name tenv =
   PatternMatch.supertype_exists
     tenv
     (fun typename _ ->
-       List.mem ~equal:String.equal immutable_collections (Typename.name typename))
+       List.mem ~equal:String.equal immutable_collections (Typ.Name.name typename))
     class_name
 
 let is_call_to_builder_class_method = function
@@ -942,9 +942,9 @@ let get_current_class_and_threadsafe_superclasses tenv pname =
 let calculate_addendum_message tenv pname =
   match get_current_class_and_threadsafe_superclasses tenv pname with
   | Some (current_class,thread_safe_annotated_classes) ->
-      if not (List.mem ~equal:Typename.equal thread_safe_annotated_classes current_class) then
+      if not (List.mem ~equal:Typ.Name.equal thread_safe_annotated_classes current_class) then
         match thread_safe_annotated_classes with
-        | hd::_ -> F.asprintf "\n Note: Superclass %a is marked @ThreadSafe." Typename.pp hd
+        | hd::_ -> F.asprintf "\n Note: Superclass %a is marked @ThreadSafe." Typ.Name.pp hd
         | [] -> ""
       else ""
   | _ -> ""
diff --git a/infer/src/checkers/annotationReachability.ml b/infer/src/checkers/annotationReachability.ml
index d1420f74e..ea3406b08 100644
--- a/infer/src/checkers/annotationReachability.ml
+++ b/infer/src/checkers/annotationReachability.ml
@@ -116,7 +116,7 @@ let is_modeled_expensive tenv = function
   | Typ.Procname.Java proc_name_java as proc_name ->
       not (BuiltinDecl.is_declared proc_name) &&
       let is_subclass =
-        let classname = Typename.Java.from_string (Typ.Procname.java_get_class_name proc_name_java) in
+        let classname = Typ.Name.Java.from_string (Typ.Procname.java_get_class_name proc_name_java) in
         PatternMatch.is_subtype_of_str tenv classname in
       Inferconfig.modeled_expensive_matcher is_subclass proc_name
   | _ ->
@@ -127,7 +127,7 @@ let is_allocator tenv pname =
   | Typ.Procname.Java pname_java ->
       let is_throwable () =
         let class_name =
-          Typename.Java.from_string (Typ.Procname.java_get_class_name pname_java) in
+          Typ.Name.Java.from_string (Typ.Procname.java_get_class_name pname_java) in
         PatternMatch.is_throwable tenv class_name in
       Typ.Procname.is_constructor pname
       && not (BuiltinDecl.is_declared pname)
diff --git a/infer/src/checkers/checkers.ml b/infer/src/checkers/checkers.ml
index 73cfd1206..ea9279d6e 100644
--- a/infer/src/checkers/checkers.ml
+++ b/infer/src/checkers/checkers.ml
@@ -200,7 +200,7 @@ let callback_check_write_to_parcel_java
       String.equal (Typ.Procname.java_get_method pname_java) "writeToParcel" in
     let expr_match () = Exp.is_this this_expr in
     let type_match () =
-      let class_name = Typename.Java.from_string "android.os.Parcelable" in
+      let class_name = Typ.Name.Java.from_string "android.os.Parcelable" in
       match this_type with
       | Typ.Tptr (Tstruct name, _) | Tstruct name ->
           PatternMatch.is_immediate_subtype tenv name class_name
diff --git a/infer/src/checkers/fragmentRetainsViewChecker.ml b/infer/src/checkers/fragmentRetainsViewChecker.ml
index 87871061e..4e0e924a5 100644
--- a/infer/src/checkers/fragmentRetainsViewChecker.ml
+++ b/infer/src/checkers/fragmentRetainsViewChecker.ml
@@ -31,12 +31,12 @@ let callback_fragment_retains_view_java
     | _ -> false in
   (* is [fldname] a View type declared by [class_typename]? *)
   let is_declared_view_typ class_typename (fldname, fld_typ, _) =
-    let fld_classname = Typename.Java.from_string (Ident.java_fieldname_get_class fldname) in
-    Typename.equal fld_classname class_typename && fld_typ_is_view fld_typ in
+    let fld_classname = Typ.Name.Java.from_string (Ident.java_fieldname_get_class fldname) in
+    Typ.Name.equal fld_classname class_typename && fld_typ_is_view fld_typ in
   if is_on_destroy_view then
     begin
       let class_typename =
-        Typename.Java.from_string (Typ.Procname.java_get_class_name pname_java) in
+        Typ.Name.Java.from_string (Typ.Procname.java_get_class_name pname_java) in
       match Tenv.lookup tenv class_typename with
       | Some { fields } when AndroidFramework.is_fragment tenv class_typename ->
           let declared_view_fields =
diff --git a/infer/src/checkers/immutableChecker.ml b/infer/src/checkers/immutableChecker.ml
index bfac711b6..a10a2c28a 100644
--- a/infer/src/checkers/immutableChecker.ml
+++ b/infer/src/checkers/immutableChecker.ml
@@ -25,8 +25,8 @@ let check_immutable_cast tenv curr_pname curr_pdesc typ_expected typ_found_opt l
           ] in
         let in_casts expected given =
           List.exists ~f:(fun (x, y) ->
-              String.equal (Typename.name expected) x
-              && String.equal (Typename.name given) y
+              String.equal (Typ.Name.name expected) x
+              && String.equal (Typ.Name.name given) y
             ) casts in
         match PatternMatch.type_get_class_name typ_expected,
               PatternMatch.type_get_class_name typ_found with
@@ -38,8 +38,8 @@ let check_immutable_cast tenv curr_pname curr_pdesc typ_expected typ_found_opt l
                     "Method %s returns %a but the return type is %a. \
                      Make sure that users of this method do not try to modify the collection."
                     (Typ.Procname.to_simplified_string curr_pname)
-                    Typename.pp name_given
-                    Typename.pp name_expected in
+                    Typ.Name.pp name_given
+                    Typ.Name.pp name_expected in
                 Checkers.ST.report_error tenv
                   curr_pname
                   curr_pdesc
diff --git a/infer/src/checkers/patternMatch.ml b/infer/src/checkers/patternMatch.ml
index 72035f7f1..266c0635b 100644
--- a/infer/src/checkers/patternMatch.ml
+++ b/infer/src/checkers/patternMatch.ml
@@ -26,7 +26,7 @@ type taint_spec = {
 
 let type_is_object typ =
   match typ with
-  | Typ.Tptr (Tstruct name, _) -> Typename.equal name Typename.Java.java_lang_object
+  | Typ.Tptr (Tstruct name, _) -> Typ.Name.equal name Typ.Name.Java.java_lang_object
   | _ -> false
 
 let java_proc_name_with_class_method pn_java class_with_path method_name =
@@ -56,16 +56,16 @@ let rec supertype_find_map_opt tenv f name =
 
 let is_immediate_subtype tenv this_type_name super_type_name =
   match Tenv.lookup tenv this_type_name with
-  | Some {supers} -> List.exists ~f:(Typename.equal super_type_name) supers
+  | Some {supers} -> List.exists ~f:(Typ.Name.equal super_type_name) supers
   | None -> false
 
 (** return true if [typ0] <: [typ1] *)
 let is_subtype tenv name0 name1 =
-  supertype_exists tenv (fun name _ -> Typename.equal name name1) name0
+  supertype_exists tenv (fun name _ -> Typ.Name.equal name name1) name0
 
 let is_subtype_of_str tenv cn1 classname_str =
-  let typename = Typename.Java.from_string classname_str in
-  Typename.equal cn1 typename ||
+  let typename = Typ.Name.Java.from_string classname_str in
+  Typ.Name.equal cn1 typename ||
   is_subtype tenv cn1 typename
 
 (** The type the method is invoked on *)
@@ -98,32 +98,32 @@ let type_get_annotation tenv (typ: Typ.t): Annot.Item.t option =
     )
   | _ -> None
 
-let type_has_direct_supertype tenv (typ : Typ.t) (class_name : Typename.t) =
-  List.exists ~f:(fun cn -> Typename.equal cn class_name) (type_get_direct_supertypes tenv typ)
+let type_has_direct_supertype tenv (typ : Typ.t) (class_name : Typ.Name.t) =
+  List.exists ~f:(fun cn -> Typ.Name.equal cn class_name) (type_get_direct_supertypes tenv typ)
 
 let type_has_supertype
     (tenv: Tenv.t)
     (typ: Typ.t)
-    (class_name: Typename.t): bool =
+    (class_name: Typ.Name.t): bool =
   let rec has_supertype typ visited =
     if Typ.Set.mem typ visited then
       false
     else
       let supers = type_get_direct_supertypes tenv typ in
       let match_supertype cn =
-        let match_name () = Typename.equal cn class_name in
+        let match_name () = Typ.Name.equal cn class_name in
         let has_indirect_supertype () = has_supertype (Typ.Tstruct cn) (Typ.Set.add typ visited) in
         (match_name () || has_indirect_supertype ()) in
       List.exists ~f:match_supertype supers in
   has_supertype typ Typ.Set.empty
 
 let type_is_nested_in_direct_supertype tenv t n =
-  let is_nested_in cn1 cn2 = String.is_prefix ~prefix:(Typename.name cn1 ^ "$") (Typename.name cn2) in
+  let is_nested_in cn1 cn2 = String.is_prefix ~prefix:(Typ.Name.name cn1 ^ "$") (Typ.Name.name cn2) in
   List.exists ~f:(is_nested_in n) (type_get_direct_supertypes tenv t)
 
 let rec get_type_name = function
   | Typ.Tstruct name ->
-      Typename.name name
+      Typ.Name.name name
   | Typ.Tptr (t, _) -> get_type_name t
   | _ -> "_"
 
@@ -252,7 +252,7 @@ let type_is_class typ =
   | _ -> false
 
 let initializer_classes =
-  List.map ~f:Typename.Java.from_string
+  List.map ~f:Typ.Name.Java.from_string
     [
       "android.app.Activity";
       "android.app.Application";
@@ -346,7 +346,7 @@ let override_exists f tenv proc_name =
   f proc_name ||
   match proc_name with
   | Typ.Procname.Java proc_name_java ->
-      let type_name = Typename.Java.from_string (Typ.Procname.java_get_class_name proc_name_java) in
+      let type_name = Typ.Name.Java.from_string (Typ.Procname.java_get_class_name proc_name_java) in
       List.exists
         ~f:(super_type_exists tenv)
         (type_get_direct_supertypes tenv (Typ.Tstruct type_name))
diff --git a/infer/src/checkers/patternMatch.mli b/infer/src/checkers/patternMatch.mli
index b92f37ff4..9bdf97335 100644
--- a/infer/src/checkers/patternMatch.mli
+++ b/infer/src/checkers/patternMatch.mli
@@ -51,21 +51,21 @@ val is_getter : Typ.Procname.java -> bool
 val is_setter : Typ.Procname.java -> bool
 
 (** Is the type a direct subtype of the typename? *)
-val is_immediate_subtype : Tenv.t -> Typename.t -> Typename.t -> bool
+val is_immediate_subtype : Tenv.t -> Typ.Name.t -> Typ.Name.t -> bool
 
 (** Is the type a transitive subtype of the typename? *)
-val is_subtype : Tenv.t -> Typename.t -> Typename.t -> bool
+val is_subtype : Tenv.t -> Typ.Name.t -> Typ.Name.t -> bool
 
 (** Resolve [typ_str] in [tenv], then check [typ] <: [typ_str] *)
-val is_subtype_of_str : Tenv.t -> Typename.t -> string -> bool
+val is_subtype_of_str : Tenv.t -> Typ.Name.t -> string -> bool
 
 (** Holds iff the predicate holds on a supertype of the named type, including the type itself *)
-val supertype_exists : Tenv.t -> (Typename.t -> Typ.Struct.t -> bool) -> Typename.t -> bool
+val supertype_exists : Tenv.t -> (Typ.Name.t -> Typ.Struct.t -> bool) -> Typ.Name.t -> bool
 
 (** Return the first non-None result found when applying the given function to supertypes of the
     named type, including the type itself *)
 val supertype_find_map_opt :
-  Tenv.t -> (Typename.t -> Typ.Struct.t -> 'a option) -> Typename.t -> 'a option
+  Tenv.t -> (Typ.Name.t -> Typ.Struct.t -> 'a option) -> Typ.Name.t -> 'a option
 
 (** Get the name of the type of a constant *)
 val java_get_const_type_name : Const.t -> string
@@ -93,16 +93,16 @@ val override_iter : (Typ.Procname.t -> unit) -> Tenv.t -> Typ.Procname.t -> unit
 val type_get_annotation : Tenv.t -> Typ.t -> Annot.Item.t option
 
 (** Get the class name of the type *)
-val type_get_class_name : Typ.t -> Typename.t option
+val type_get_class_name : Typ.t -> Typ.Name.t option
 
-val type_get_direct_supertypes : Tenv.t -> Typ.t -> Typename.t list
+val type_get_direct_supertypes : Tenv.t -> Typ.t -> Typ.Name.t list
 
-val type_has_direct_supertype : Tenv.t -> Typ.t -> Typename.t -> bool
+val type_has_direct_supertype : Tenv.t -> Typ.t -> Typ.Name.t -> bool
 
 (** Is the type a class type *)
 val type_is_class : Typ.t -> bool
 
-val type_is_nested_in_direct_supertype : Tenv.t -> Typ.t -> Typename.t -> bool
+val type_is_nested_in_direct_supertype : Tenv.t -> Typ.t -> Typ.Name.t -> bool
 
 (** Is the type java.lang.Object *)
 val type_is_object : Typ.t -> bool
@@ -111,14 +111,14 @@ val type_is_object : Typ.t -> bool
 val get_fields_nullified : Procdesc.t -> Ident.FieldSet.t
 
 (** [is_exception tenv class_name] checks if class_name is of type java.lang.Exception *)
-val is_exception : Tenv.t -> Typename.t -> bool
+val is_exception : Tenv.t -> Typ.Name.t -> bool
 
 (** [is_throwable tenv class_name] checks if class_name is of type java.lang.Throwable *)
-val is_throwable : Tenv.t -> Typename.t -> bool
+val is_throwable : Tenv.t -> Typ.Name.t -> bool
 
 (** [is_runtime_exception tenv class_name] checks if classname is
     of type java.lang.RuntimeException *)
-val is_runtime_exception : Tenv.t -> Typename.t -> bool
+val is_runtime_exception : Tenv.t -> Typ.Name.t -> bool
 
 (** tests whether any class attributes (e.g., @ThreadSafe) pass check of first argument,
      including supertypes*)
@@ -130,4 +130,4 @@ val check_current_class_attributes : (Annot.Item.t -> bool) -> Tenv.t -> Typ.Pro
 
 (** find superclasss with attributes (e.g., @ThreadSafe), including current class*)
 val find_superclasses_with_attributes : (Annot.Item.t -> bool) -> Tenv.t
-  -> Typename.t -> Typename.t list
+  -> Typ.Name.t -> Typ.Name.t list
diff --git a/infer/src/clang/CProcname.ml b/infer/src/clang/CProcname.ml
index 5adf85306..74a8ea88c 100644
--- a/infer/src/clang/CProcname.ml
+++ b/infer/src/clang/CProcname.ml
@@ -113,10 +113,10 @@ let mk_fresh_block_procname defining_proc =
   Typ.Procname.mangled_objc_block name
 
 
-let get_class_typename method_decl_info =
+let get_class_typename ?tenv method_decl_info =
   let class_ptr = Option.value_exn method_decl_info.Clang_ast_t.di_parent_pointer in
   match CAst_utils.get_decl class_ptr with
-  | Some class_decl -> CType_decl.get_record_typename class_decl
+  | Some class_decl -> CType_decl.get_record_typename ?tenv class_decl
   | None -> assert false
 
 module NoAstDecl = struct
@@ -143,10 +143,10 @@ let from_decl translation_unit_context ?tenv meth_decl =
   | CXXDestructorDecl (decl_info, name_info, _, fdi, mdi) ->
       let mangled = get_mangled_method_name fdi mdi in
       let method_name = CAst_utils.get_unqualified_name name_info in
-      let class_typename = get_class_typename decl_info in
+      let class_typename = get_class_typename ?tenv decl_info in
       mk_cpp_method ?tenv class_typename method_name ~meth_decl mangled
   | ObjCMethodDecl (decl_info, name_info, mdi) ->
-      let class_typename = get_class_typename decl_info in
+      let class_typename = get_class_typename ?tenv decl_info in
       let method_name = name_info.Clang_ast_t.ni_name in
       let is_instance = mdi.Clang_ast_t.omdi_is_instance_method in
       let method_kind = Typ.Procname.objc_method_kind_of_bool is_instance in
diff --git a/infer/src/clang/CProcname.mli b/infer/src/clang/CProcname.mli
index ee35a9da6..a22921bb2 100644
--- a/infer/src/clang/CProcname.mli
+++ b/infer/src/clang/CProcname.mli
@@ -19,9 +19,9 @@ module NoAstDecl : sig
   val c_function_of_string :
     CFrontend_config.translation_unit_context -> Tenv.t -> string -> Typ.Procname.t
 
-  val cpp_method_of_string : Tenv.t -> Typename.t -> string -> Typ.Procname.t
+  val cpp_method_of_string : Tenv.t -> Typ.Name.t -> string -> Typ.Procname.t
 
-  val objc_method_of_string_kind : Typename.t -> string -> Typ.Procname.objc_cpp_method_kind ->
+  val objc_method_of_string_kind : Typ.Name.t -> string -> Typ.Procname.objc_cpp_method_kind ->
     Typ.Procname.t
 
 end
diff --git a/infer/src/clang/CType.ml b/infer/src/clang/CType.ml
index 7f758a526..a978c0308 100644
--- a/infer/src/clang/CType.ml
+++ b/infer/src/clang/CType.ml
@@ -24,16 +24,16 @@ let remove_pointer_to_typ typ =
 let objc_classname_of_type typ =
   match typ with
   | Typ.Tstruct name -> name
-  | Typ.Tfun _ -> Typename.Objc.from_string CFrontend_config.objc_object
+  | Typ.Tfun _ -> Typ.Name.Objc.from_string CFrontend_config.objc_object
   | _ ->
       Logging.out_debug
         "Classname of type cannot be extracted in type %s" (Typ.to_string typ);
-      Typename.Objc.from_string "undefined"
+      Typ.Name.Objc.from_string "undefined"
 
 let is_class typ =
   match typ with
   | Typ.Tptr (Tstruct name, _) ->
-      String.equal (Typename.name name) CFrontend_config.objc_class
+      String.equal (Typ.Name.name name) CFrontend_config.objc_class
   | _ -> false
 
 let rec return_type_of_function_type_ptr type_ptr =
diff --git a/infer/src/clang/CType.mli b/infer/src/clang/CType.mli
index e4474a4e8..6f08ff72f 100644
--- a/infer/src/clang/CType.mli
+++ b/infer/src/clang/CType.mli
@@ -13,7 +13,7 @@ open! IStd
 
 val add_pointer_to_typ : Typ.t -> Typ.t
 
-val objc_classname_of_type : Typ.t -> Typename.t
+val objc_classname_of_type : Typ.t -> Typ.Name.t
 
 val remove_pointer_to_typ : Typ.t -> Typ.t
 
diff --git a/infer/src/clang/CType_decl.ml b/infer/src/clang/CType_decl.ml
index c154bac00..ce64ea4df 100644
--- a/infer/src/clang/CType_decl.ml
+++ b/infer/src/clang/CType_decl.ml
@@ -32,7 +32,7 @@ let add_predefined_basic_types () =
     CAst_utils.update_sil_types_map tp return_type in
   let sil_void_type = CType_to_sil_type.sil_type_of_builtin_type_kind `Void in
   let sil_char_type = CType_to_sil_type.sil_type_of_builtin_type_kind `Char_S in
-  let sil_nsarray_type = Typ.Tstruct (Typename.Objc.from_string CFrontend_config.nsarray_cl) in
+  let sil_nsarray_type = Typ.Tstruct (Typ.Name.Objc.from_string CFrontend_config.nsarray_cl) in
   let sil_id_type = CType_to_sil_type.get_builtin_objc_type `ObjCId in
   add_basic_type create_int_type `Int;
   add_basic_type create_void_type `Void;
@@ -55,33 +55,12 @@ let create_c_record_typename opt_type =
   | `Type s ->
       (let buf = Str.split (Str.regexp "[ \t]+") s in
        match buf with
-       | "struct":: _ -> Typename.C.from_string
-       | "class":: _ -> Typename.Cpp.from_string
-       | "union":: _ -> Typename.C.union_from_string
-       | _ -> Typename.C.from_string)
+       | "struct":: _ -> Typ.Name.C.from_string
+       | "class":: _ -> Typ.Name.Cpp.from_string
+       | "union":: _ -> Typ.Name.C.union_from_string
+       | _ -> Typ.Name.C.from_string)
   | _ -> assert false
 
-(* We need to take the name out of the type as the struct can be anonymous*)
-let get_record_typename decl =
-  let open Clang_ast_t in
-  match decl with
-  | RecordDecl (_, name_info, opt_type, _, _, _, _) ->
-      CAst_utils.get_qualified_name name_info |> create_c_record_typename opt_type
-  | CXXRecordDecl (_, name_info, _, _, _, _, _, _)
-  | ClassTemplateSpecializationDecl (_, name_info, _, _, _, _, _, _, _) ->
-      (* we use Csu.Class for C++ because we expect Csu.Class csu from *)
-      (* types that have methods. And in C++ struct/class/union can have methods *)
-      CAst_utils.get_qualified_name name_info |> Typename.Cpp.from_string
-  | ObjCInterfaceDecl (_, name_info, _, _, _)
-  | ObjCImplementationDecl (_, name_info, _, _, _)
-  | ObjCProtocolDecl (_, name_info, _, _, _)
-  | ObjCCategoryDecl (_, name_info, _, _, _)
-  | ObjCCategoryImplDecl (_, name_info, _, _, _) ->
-      CAst_utils.get_qualified_name name_info |> Typename.Objc.from_string
-  | _ -> assert false
-
-let get_record_name decl = get_record_typename decl |> Typename.name
-
 let get_class_template_name = function
   | Clang_ast_t.ClassTemplateDecl (_, name_info, _ ) -> CAst_utils.get_qualified_name name_info
   | _ -> assert false
@@ -99,12 +78,6 @@ let get_superclass_decls decl =
       List.map ~f:get_decl_or_fail base_ptr
   | _ -> []
 
-(** fetches list of superclasses for C++ classes *)
-let get_superclass_list_cpp decl =
-  let base_decls = get_superclass_decls decl in
-  let get_super_field super_decl = Typename.Cpp.from_string (get_record_name super_decl) in
-  List.map ~f:get_super_field base_decls
-
 let get_translate_as_friend_decl decl_list =
   let is_translate_as_friend_name (_, name_info) =
     let translate_as_str = "infer_traits::TranslateAsType" in
@@ -181,23 +154,54 @@ and get_template_specialization tenv = function
       Typ.Template (tname, args_in_sil)
   | _ -> Typ.NoTemplate
 
+(* We need to take the name out of the type as the struct can be anonymous
+   If tenv is not passed, then template instantiaion information may be incorrect,
+   as it defaults to Typ.NoTemplate *)
+and get_record_typename ?tenv decl =
+  let open Clang_ast_t in
+  match decl with
+  | RecordDecl (_, name_info, opt_type, _, _, _, _) ->
+      CAst_utils.get_qualified_name name_info |> create_c_record_typename opt_type
+  | CXXRecordDecl (_, name_info, _, _, _, _, _, _)
+  | ClassTemplateSpecializationDecl (_, name_info, _, _, _, _, _, _, _) ->
+      (* we use Csu.Class for C++ because we expect Csu.Class csu from *)
+      (* types that have methods. And in C++ struct/class/union can have methods *)
+      let name_str = CAst_utils.get_qualified_name name_info in
+      let templ_info = match tenv with
+        | Some t -> get_template_specialization t decl
+        | None -> Typ.NoTemplate in
+      Typ.Name.Cpp.from_template_string templ_info name_str
+  | ObjCInterfaceDecl (_, name_info, _, _, _)
+  | ObjCImplementationDecl (_, name_info, _, _, _)
+  | ObjCProtocolDecl (_, name_info, _, _, _)
+  | ObjCCategoryDecl (_, name_info, _, _, _)
+  | ObjCCategoryImplDecl (_, name_info, _, _, _) ->
+      CAst_utils.get_qualified_name name_info |> Typ.Name.Objc.from_string
+  | _ -> assert false
+
+(** fetches list of superclasses for C++ classes *)
+and get_superclass_list_cpp tenv decl =
+  let base_decls = get_superclass_decls decl in
+  let get_super_field super_decl = get_record_typename ~tenv super_decl in
+  List.map ~f:get_super_field base_decls
+
 and get_record_struct_type tenv definition_decl =
   let open Clang_ast_t in
   match definition_decl with
   | ClassTemplateSpecializationDecl (_, _, _, type_ptr, _, _, record_decl_info, _, _)
   | CXXRecordDecl (_, _, _, type_ptr, _, _, record_decl_info, _)
   | RecordDecl (_, _, _, type_ptr, _, _, record_decl_info) ->
-      let sil_typename = get_record_typename definition_decl in
+      let sil_typename = get_record_typename ~tenv definition_decl in
       (match Tenv.lookup tenv sil_typename with
        | Some _ -> Typ.Tstruct sil_typename (* just reuse what is already in tenv *)
        | None ->
            let is_complete_definition = record_decl_info.Clang_ast_t.rdi_is_complete_definition in
            let extra_fields =
-             if CTrans_models.is_objc_memory_model_controlled (Typename.name sil_typename) then
+             if CTrans_models.is_objc_memory_model_controlled (Typ.Name.name sil_typename) then
                [Typ.Struct.objc_ref_counter_field]
              else [] in
            let annots =
-             if Typename.Cpp.is_class sil_typename then Annot.Class.cpp
+             if Typ.Name.Cpp.is_class sil_typename then Annot.Class.cpp
              else Annot.Item.empty (* No annotations for structs *) in
            if is_complete_definition then (
              CAst_utils.update_sil_types_map type_ptr (Typ.Tstruct sil_typename);
@@ -205,7 +209,7 @@ and get_record_struct_type tenv definition_decl =
              let fields = CGeneral_utils.append_no_duplicates_fields non_statics extra_fields in
              let statics = [] in (* Note: We treat static field same as global variables *)
              let methods = [] in (* C++ methods are not put into tenv (info isn't used) *)
-             let supers = get_superclass_list_cpp definition_decl in
+             let supers = get_superclass_list_cpp tenv definition_decl in
              let specialization = get_template_specialization tenv definition_decl in
              Tenv.mk_struct tenv ~fields ~statics ~methods ~supers ~annots ~specialization
                sil_typename |> ignore;
diff --git a/infer/src/clang/CType_decl.mli b/infer/src/clang/CType_decl.mli
index 8f2295381..beee0d823 100644
--- a/infer/src/clang/CType_decl.mli
+++ b/infer/src/clang/CType_decl.mli
@@ -11,9 +11,7 @@ open! IStd
 
 (** Processes types and record declarations by adding them to the tenv *)
 
-val get_record_name : Clang_ast_t.decl -> string
-
-val get_record_typename : Clang_ast_t.decl -> Typename.t
+val get_record_typename : ?tenv:Tenv.t -> Clang_ast_t.decl -> Typ.Name.t
 
 val add_types_from_decl_to_tenv : Tenv.t -> Clang_ast_t.decl -> Typ.t
 
@@ -23,7 +21,7 @@ val add_predefined_types : Tenv.t -> unit
 
 val type_ptr_to_sil_type : Tenv.t -> Clang_ast_t.type_ptr -> Typ.t
 
-val class_from_pointer_type : Tenv.t -> Clang_ast_t.type_ptr -> Typename.t
+val class_from_pointer_type : Tenv.t -> Clang_ast_t.type_ptr -> Typ.Name.t
 
 val get_class_type_np : Tenv.t -> Clang_ast_t.expr_info ->
   Clang_ast_t.obj_c_message_expr_info -> Typ.t
diff --git a/infer/src/clang/ast_expressions.ml b/infer/src/clang/ast_expressions.ml
index c400ed2e0..56415d401 100644
--- a/infer/src/clang/ast_expressions.ml
+++ b/infer/src/clang/ast_expressions.ml
@@ -111,7 +111,7 @@ let create_class_qual_type ?(is_const=false) typename =
   create_qual_type ~is_const @@ create_class_type typename
 
 let make_objc_class_type class_name =
-  create_class_type (Typename.Objc.from_string class_name)
+  create_class_type (Typ.Name.Objc.from_string class_name)
 
 let create_struct_type struct_name = `StructType struct_name
 
diff --git a/infer/src/clang/ast_expressions.mli b/infer/src/clang/ast_expressions.mli
index 045f9f1dd..fdae03d1c 100644
--- a/infer/src/clang/ast_expressions.mli
+++ b/infer/src/clang/ast_expressions.mli
@@ -44,10 +44,10 @@ val create_void_unsigned_long_type : type_ptr
 
 val create_void_void_type : type_ptr
 
-val create_class_type : Typename.t -> type_ptr
-val create_class_qual_type : ?is_const:bool -> Typename.t -> qual_type
+val create_class_type : Typ.Name.t -> type_ptr
+val create_class_qual_type : ?is_const:bool -> Typ.Name.t -> qual_type
 
-val create_struct_type : Typename.t -> type_ptr
+val create_struct_type : Typ.Name.t -> type_ptr
 
 val create_pointer_type : type_ptr -> type_ptr
 val create_pointer_qual_type : is_const:bool -> type_ptr -> qual_type
@@ -79,7 +79,7 @@ val make_message_expr : type_ptr -> string -> stmt -> stmt_info -> bool -> stmt
 
 val make_binary_stmt : stmt -> stmt -> stmt_info -> expr_info -> binary_operator_info -> stmt
 
-val make_obj_c_message_expr_info_class : string -> Typename.t -> pointer option ->
+val make_obj_c_message_expr_info_class : string -> Typ.Name.t -> pointer option ->
   obj_c_message_expr_info
 
 val make_obj_c_message_expr_info_instance : string -> obj_c_message_expr_info
diff --git a/infer/src/clang/cContext.ml b/infer/src/clang/cContext.ml
index 7b70770b2..3cc3e35ec 100644
--- a/infer/src/clang/cContext.ml
+++ b/infer/src/clang/cContext.ml
@@ -103,9 +103,11 @@ let get_curr_class_name curr_class =
   | None -> assert false in
   CAst_utils.get_qualified_name name_info
 
-let get_curr_class_typename curr_class =
+let get_curr_class_typename context =
+  let tenv = context.tenv in
+  let curr_class = get_curr_class context in
   match get_curr_class_ptr curr_class |> CAst_utils.get_decl with
-  | Some decl -> CType_decl.get_record_typename decl
+  | Some decl -> CType_decl.get_record_typename ~tenv decl
   | None -> assert false
 
 let curr_class_to_string curr_class =
diff --git a/infer/src/clang/cContext.mli b/infer/src/clang/cContext.mli
index 5e4e7c3d9..d85aa445c 100644
--- a/infer/src/clang/cContext.mli
+++ b/infer/src/clang/cContext.mli
@@ -47,7 +47,7 @@ val get_curr_class : t -> curr_class
 
 val get_curr_class_name : curr_class -> string
 
-val get_curr_class_typename : curr_class -> Typename.t
+val get_curr_class_typename : t -> Typ.Name.t
 
 val get_curr_class_decl_ptr : curr_class -> Clang_ast_t.pointer
 
diff --git a/infer/src/clang/cField_decl.ml b/infer/src/clang/cField_decl.ml
index 8e2e5c891..cbad2af16 100644
--- a/infer/src/clang/cField_decl.ml
+++ b/infer/src/clang/cField_decl.ml
@@ -16,7 +16,7 @@ module L = Logging
 type field_type = Ident.fieldname * Typ.t * (Annot.t * bool) list
 
 let rec get_fields_super_classes tenv super_class =
-  Logging.out_debug "   ... Getting fields of superclass '%s'\n" (Typename.to_string super_class);
+  Logging.out_debug "   ... Getting fields of superclass '%s'\n" (Typ.Name.to_string super_class);
   match Tenv.lookup tenv super_class with
   | None -> []
   | Some { fields; supers = super_class :: _ } ->
@@ -29,7 +29,7 @@ let fields_superclass tenv interface_decl_info =
   | Some dr ->
       (match dr.Clang_ast_t.dr_name with
        | Some sc ->
-           let classname = Typename.Objc.from_string (CAst_utils.get_qualified_name sc) in
+           let classname = Typ.Name.Objc.from_string (CAst_utils.get_qualified_name sc) in
            get_fields_super_classes tenv classname
        | _ -> [])
   | _ -> []
@@ -78,7 +78,7 @@ let rec get_fields type_ptr_to_sil_type tenv decl_list =
 (* Add potential extra fields defined only in the implementation of the class *)
 (* to the info given in the interface. Update the tenv accordingly. *)
 let add_missing_fields tenv class_name missing_fields =
-  let class_tn_name = Typename.Objc.from_string class_name in
+  let class_tn_name = Typ.Name.Objc.from_string class_name in
   match Tenv.lookup tenv class_tn_name with
   | Some ({ fields } as struct_typ) ->
       let new_fields = CGeneral_utils.append_no_duplicates_fields fields missing_fields in
diff --git a/infer/src/clang/cFrontend_decl.ml b/infer/src/clang/cFrontend_decl.ml
index 6e6f8c9be..4478ffd73 100644
--- a/infer/src/clang/cFrontend_decl.ml
+++ b/infer/src/clang/cFrontend_decl.ml
@@ -204,7 +204,7 @@ struct
 
        | ObjCImplementationDecl(decl_info, _, decl_list, _, _) ->
            let curr_class = CContext.ContextClsDeclPtr dec_ptr in
-           let class_typename = CType_decl.get_record_typename dec in
+           let class_typename = CType_decl.get_record_typename ~tenv dec in
            let type_ptr_to_sil_type = CType_decl.type_ptr_to_sil_type in
            ignore (ObjcInterface_decl.interface_impl_declaration type_ptr_to_sil_type tenv dec);
            CMethod_trans.add_default_method_for_class trans_unit_ctx class_typename decl_info;
diff --git a/infer/src/clang/cGeneral_utils.ml b/infer/src/clang/cGeneral_utils.ml
index cda00b399..44fae02fb 100644
--- a/infer/src/clang/cGeneral_utils.ml
+++ b/infer/src/clang/cGeneral_utils.ml
@@ -38,7 +38,7 @@ let rec append_no_duplicates eq list1 list2 =
   | [] -> list1
 
 let append_no_duplicates_csu list1 list2 =
-  append_no_duplicates Typename.equal list1 list2
+  append_no_duplicates Typ.Name.equal list1 list2
 
 let append_no_duplicates_annotations list1 list2 =
   let eq (annot1, _) (annot2, _) = String.equal annot1.Annot.class_name annot2.Annot.class_name in
diff --git a/infer/src/clang/cGeneral_utils.mli b/infer/src/clang/cGeneral_utils.mli
index 0852f9c1f..2cfec15b6 100644
--- a/infer/src/clang/cGeneral_utils.mli
+++ b/infer/src/clang/cGeneral_utils.mli
@@ -21,7 +21,7 @@ val append_no_duplicates_fields : (Ident.fieldname * Typ.t * Annot.Item.t) list
   (Ident.fieldname * Typ.t * Annot.Item.t) list
 
 val append_no_duplicates_csu :
-  Typename.t list -> Typename.t list -> Typename.t list
+  Typ.Name.t list -> Typ.Name.t list -> Typ.Name.t list
 
 val sort_fields :
   (Ident.fieldname * Typ.t * Annot.Item.t) list ->
diff --git a/infer/src/clang/cMethod_trans.ml b/infer/src/clang/cMethod_trans.ml
index 3f2f1569c..245ba7e29 100644
--- a/infer/src/clang/cMethod_trans.ml
+++ b/infer/src/clang/cMethod_trans.ml
@@ -250,7 +250,7 @@ let get_superclass_curr_class_objc context =
         super_of_decl_ref_opt ocidi.ocidi_class_interface
     | _ -> assert false in
   match CContext.get_curr_class context with
-  | CContext.ContextClsDeclPtr ptr -> Typename.Objc.from_string (retreive_super_name ptr)
+  | CContext.ContextClsDeclPtr ptr -> Typ.Name.Objc.from_string (retreive_super_name ptr)
   | CContext.ContextNoCls -> assert false
 
 (* Gets the class name from a method signature found by clang, if search is successful *)
diff --git a/infer/src/clang/cMethod_trans.mli b/infer/src/clang/cMethod_trans.mli
index 50fa6a6f2..bec1baf0c 100644
--- a/infer/src/clang/cMethod_trans.mli
+++ b/infer/src/clang/cMethod_trans.mli
@@ -36,10 +36,10 @@ val get_objc_method_data : Clang_ast_t.obj_c_message_expr_info ->
   (string * Clang_ast_t.pointer option * method_call_type)
 
 val get_class_name_method_call_from_receiver_kind : CContext.t ->
-  Clang_ast_t.obj_c_message_expr_info -> (Exp.t * Typ.t) list -> Typename.t
+  Clang_ast_t.obj_c_message_expr_info -> (Exp.t * Typ.t) list -> Typ.Name.t
 
 val get_class_name_method_call_from_clang : CFrontend_config.translation_unit_context -> Tenv.t ->
-  Clang_ast_t.obj_c_message_expr_info -> Typename.t option
+  Clang_ast_t.obj_c_message_expr_info -> Typ.Name.t option
 
 val method_signature_of_decl : CFrontend_config.translation_unit_context -> Tenv.t ->
   Clang_ast_t.decl -> CModule_type.block_data option ->
@@ -51,10 +51,10 @@ val method_signature_of_pointer : CFrontend_config.translation_unit_context -> T
 val get_method_name_from_clang : Tenv.t -> CMethod_signature.method_signature option ->
   CMethod_signature.method_signature option
 
-val create_procdesc_with_pointer : CContext.t -> Clang_ast_t.pointer -> Typename.t option ->
+val create_procdesc_with_pointer : CContext.t -> Clang_ast_t.pointer -> Typ.Name.t option ->
   string -> Typ.Procname.t
 
-val add_default_method_for_class : CFrontend_config.translation_unit_context -> Typename.t ->
+val add_default_method_for_class : CFrontend_config.translation_unit_context -> Typ.Name.t ->
   Clang_ast_t.decl_info -> unit
 
 val get_procname_from_cpp_lambda : CContext.t -> Clang_ast_t.decl -> Typ.Procname.t
diff --git a/infer/src/clang/cTrans.ml b/infer/src/clang/cTrans.ml
index 3fb8e4f57..a01aaed0a 100644
--- a/infer/src/clang/cTrans.ml
+++ b/infer/src/clang/cTrans.ml
@@ -116,7 +116,7 @@ struct
     Logging.out_debug "Block %s field:\n" block_name;
     List.iter ~f:(fun (fn, _, _) ->
         Logging.out_debug "-----> field: '%s'\n" (Ident.fieldname_to_string fn)) fields;
-    let block_typename = Typename.Objc.from_string block_name in
+    let block_typename = Typ.Name.Objc.from_string block_name in
     ignore (Tenv.mk_struct tenv ~fields block_typename);
     let block_type = Typ.Tstruct block_typename in
     let trans_res =
@@ -566,7 +566,7 @@ struct
               type_ptr with
       | Some builtin_pname -> builtin_pname
       | None ->
-          let class_typename = Typename.Cpp.from_string
+          let class_typename = Typ.Name.Cpp.from_string
               (CAst_utils.get_class_name_from_member name_info) in
           CMethod_trans.create_procdesc_with_pointer context decl_ptr (Some class_typename)
             method_name in
@@ -656,8 +656,7 @@ struct
         init_expr_trans trans_state (var_exp, typ) stmt_info init_expr
       else empty_res_trans in
     let exps = if Self.is_var_self pvar (CContext.is_objc_method context) then
-        let curr_class = CContext.get_curr_class context in
-        let class_typename = CContext.get_curr_class_typename curr_class in
+        let class_typename = CContext.get_curr_class_typename context in
         if (CType.is_class typ) then
           raise (Self.SelfClassException class_typename)
         else
diff --git a/infer/src/clang/cTrans_models.ml b/infer/src/clang/cTrans_models.ml
index 3cd317549..2a787a000 100644
--- a/infer/src/clang/cTrans_models.ml
+++ b/infer/src/clang/cTrans_models.ml
@@ -11,7 +11,7 @@ open! IStd
 
 open Objc_models
 
-let class_equal class_typename class_name = String.equal (Typename.name class_typename) class_name
+let class_equal class_typename class_name = String.equal (Typ.Name.name class_typename) class_name
 
 let is_cf_non_null_alloc pname =
   String.equal (Typ.Procname.to_string pname) CFrontend_config.cf_non_null_alloc
@@ -158,7 +158,7 @@ let get_predefined_ms_retain_release method_name mk_procname lang =
   let return_type =
     if is_retain_method method_name || is_autorelease_method method_name
     then Ast_expressions.create_id_type else Ast_expressions.create_void_type in
-  let class_typename = Typename.Objc.from_string CFrontend_config.nsobject_cl in
+  let class_typename = Typ.Name.Objc.from_string CFrontend_config.nsobject_cl in
   let class_type = Ast_expressions.create_class_qual_type class_typename in
   let args = [(Mangled.from_string CFrontend_config.self, class_type)] in
   get_predefined_ms_method condition class_typename method_name Typ.Procname.ObjCInstanceMethod
diff --git a/infer/src/clang/cTrans_models.mli b/infer/src/clang/cTrans_models.mli
index f9ede4273..f8416e03d 100644
--- a/infer/src/clang/cTrans_models.mli
+++ b/infer/src/clang/cTrans_models.mli
@@ -39,8 +39,8 @@ val is_toll_free_bridging : Typ.Procname.t -> bool
 
 val is_cf_retain_release : Typ.Procname.t -> bool
 
-val get_predefined_model_method_signature : Typename.t -> string ->
-  (Typename.t -> string -> Typ.Procname.objc_cpp_method_kind -> Typ.Procname.t) ->
+val get_predefined_model_method_signature : Typ.Name.t -> string ->
+  (Typ.Name.t -> string -> Typ.Procname.objc_cpp_method_kind -> Typ.Procname.t) ->
   CFrontend_config.clang_lang -> CMethod_signature.method_signature option
 
 val is_dispatch_function_name : string -> (string * int) option
diff --git a/infer/src/clang/cTrans_utils.ml b/infer/src/clang/cTrans_utils.ml
index 91c61e2b4..c862745a7 100644
--- a/infer/src/clang/cTrans_utils.ml
+++ b/infer/src/clang/cTrans_utils.ml
@@ -574,14 +574,14 @@ let rec get_type_from_exp_stmt stmt =
 module Self =
 struct
 
-  exception SelfClassException of Typename.t
+  exception SelfClassException of Typ.Name.t
 
   let add_self_parameter_for_super_instance context procname loc mei =
     if is_superinstance mei then
       let typ, self_expr, ins =
         let t' =
           CType.add_pointer_to_typ
-            (Typ.Tstruct (CContext.get_curr_class_typename context.CContext.curr_class)) in
+            (Typ.Tstruct (CContext.get_curr_class_typename context)) in
         let e = Exp.Lvar (Pvar.mk (Mangled.from_string CFrontend_config.self) procname) in
         let id = Ident.create_fresh Ident.knormal in
         t', Exp.Var id, [Sil.Load (id, e, t', loc)] in
diff --git a/infer/src/clang/cTrans_utils.mli b/infer/src/clang/cTrans_utils.mli
index b574c3fae..5f311dc03 100644
--- a/infer/src/clang/cTrans_utils.mli
+++ b/infer/src/clang/cTrans_utils.mli
@@ -109,7 +109,7 @@ val alloc_trans :
   Typ.Procname.t option -> trans_result
 
 val new_or_alloc_trans : trans_state -> Location.t -> Clang_ast_t.stmt_info ->
-  Clang_ast_t.type_ptr -> Typename.t option -> string -> trans_result
+  Clang_ast_t.type_ptr -> Typ.Name.t option -> string -> trans_result
 
 val cpp_new_trans : Location.t -> Typ.t -> Exp.t option -> trans_result
 
@@ -202,7 +202,7 @@ end
 module Self :
 sig
 
-  exception SelfClassException of Typename.t
+  exception SelfClassException of Typ.Name.t
 
   val add_self_parameter_for_super_instance :
     CContext.t -> Typ.Procname.t -> Location.t -> Clang_ast_t.obj_c_message_expr_info ->
diff --git a/infer/src/clang/cType_to_sil_type.ml b/infer/src/clang/cType_to_sil_type.ml
index cea49f94a..324ad24b9 100644
--- a/infer/src/clang/cType_to_sil_type.ml
+++ b/infer/src/clang/cType_to_sil_type.ml
@@ -11,8 +11,8 @@ open! IStd
 
 let get_builtin_objc_typename builtin_type =
   match builtin_type with
-  | `ObjCId -> Typename.C.from_string CFrontend_config.objc_object
-  | `ObjCClass -> Typename.C.from_string CFrontend_config.objc_class
+  | `ObjCId -> Typ.Name.C.from_string CFrontend_config.objc_object
+  | `ObjCClass -> Typ.Name.C.from_string CFrontend_config.objc_class
 
 let get_builtin_objc_type builtin_type =
   let typ = Typ.Tstruct (get_builtin_objc_typename builtin_type) in
diff --git a/infer/src/clang/cType_to_sil_type.mli b/infer/src/clang/cType_to_sil_type.mli
index 5b94bb5ba..c1ebe4672 100644
--- a/infer/src/clang/cType_to_sil_type.mli
+++ b/infer/src/clang/cType_to_sil_type.mli
@@ -9,7 +9,7 @@
 
 open! IStd
 
-val get_builtin_objc_typename :  [< `ObjCClass | `ObjCId ] -> Typename.t
+val get_builtin_objc_typename :  [< `ObjCClass | `ObjCId ] -> Typ.Name.t
 
 val get_builtin_objc_type : [< `ObjCClass | `ObjCId ] -> Typ.t
 
diff --git a/infer/src/clang/clang_ast_types.ml b/infer/src/clang/clang_ast_types.ml
index 2805d3c69..d5ca36e7c 100644
--- a/infer/src/clang/clang_ast_types.ml
+++ b/infer/src/clang/clang_ast_types.ml
@@ -23,8 +23,8 @@ type t_ptr = [
   | `Prebuilt of int
   | `PointerOf of t_ptr
   | `ReferenceOf of t_ptr
-  | `ClassType of Typename.t
-  | `StructType of Typename.t
+  | `ClassType of Typ.Name.t
+  | `StructType of Typ.Name.t
   | `DeclPtr of int
   | `ErrorType
 ] [@@deriving compare]
@@ -40,8 +40,8 @@ let rec type_ptr_to_string type_ptr = match type_ptr with
   | `Prebuilt raw -> "prebuilt_" ^ (string_of_int raw)
   | `PointerOf typ -> "pointer_of_" ^ type_ptr_to_string typ
   | `ReferenceOf typ -> "reference_of_" ^ type_ptr_to_string typ
-  | `ClassType name -> "class_name_" ^ Typename.name name
-  | `StructType name -> "struct_name_" ^ Typename.name name
+  | `ClassType name -> "class_name_" ^ Typ.Name.name name
+  | `StructType name -> "struct_name_" ^ Typ.Name.name name
   | `DeclPtr raw -> "decl_ptr_" ^ (string_of_int raw)
   | `ErrorType -> "error_type"
 
diff --git a/infer/src/clang/objcCategory_decl.ml b/infer/src/clang/objcCategory_decl.ml
index bc56d5d71..2604e687b 100644
--- a/infer/src/clang/objcCategory_decl.ml
+++ b/infer/src/clang/objcCategory_decl.ml
@@ -59,7 +59,7 @@ let get_base_class_name_from_category decl =
   | Some decl_ref ->
       (match CAst_utils.get_decl decl_ref.Clang_ast_t.dr_decl_pointer with
        | Some ObjCInterfaceDecl (_, name_info, _, _, _) ->
-           Some (Typename.Objc.from_string (CAst_utils.get_qualified_name name_info))
+           Some (Typ.Name.Objc.from_string (CAst_utils.get_qualified_name name_info))
        | _ -> None)
   | None -> None
 
@@ -67,7 +67,7 @@ let get_base_class_name_from_category decl =
 (* to the corresponding class. Update the tenv accordingly.*)
 let process_category type_ptr_to_sil_type tenv class_name decl_info decl_list =
   let decl_fields = CField_decl.get_fields type_ptr_to_sil_type tenv decl_list in
-  let class_tn_name = Typename.Objc.from_string class_name in
+  let class_tn_name = Typ.Name.Objc.from_string class_name in
   let decl_key = `DeclPtr decl_info.Clang_ast_t.di_pointer in
   CAst_utils.update_sil_types_map decl_key (Typ.Tstruct class_tn_name);
   (match Tenv.lookup tenv class_tn_name with
diff --git a/infer/src/clang/objcCategory_decl.mli b/infer/src/clang/objcCategory_decl.mli
index 162685397..705025697 100644
--- a/infer/src/clang/objcCategory_decl.mli
+++ b/infer/src/clang/objcCategory_decl.mli
@@ -18,4 +18,4 @@ val category_impl_decl : CAst_utils.type_ptr_to_sil_type -> Tenv.t -> Clang_ast_
 
 val noname_category : string -> string
 
-val get_base_class_name_from_category : Clang_ast_t.decl -> Typename.t option
+val get_base_class_name_from_category : Clang_ast_t.decl -> Typ.Name.t option
diff --git a/infer/src/clang/objcInterface_decl.ml b/infer/src/clang/objcInterface_decl.ml
index ac8f173cf..48cc65a7a 100644
--- a/infer/src/clang/objcInterface_decl.ml
+++ b/infer/src/clang/objcInterface_decl.ml
@@ -60,8 +60,8 @@ let get_interface_supers super_opt protocols =
   let super_class =
     match super_opt with
     | None -> []
-    | Some super -> [Typename.Objc.from_string super] in
-  let protocol_names = List.map ~f:Typename.Objc.protocol_from_string protocols in
+    | Some super -> [Typ.Name.Objc.from_string super] in
+  let protocol_names = List.map ~f:Typ.Name.Objc.protocol_from_string protocols in
   let super_classes = super_class@protocol_names in
   super_classes
 
@@ -77,7 +77,7 @@ let create_supers_fields type_ptr_to_sil_type tenv decl_list
 let add_class_to_tenv type_ptr_to_sil_type tenv decl_info name_info decl_list ocidi =
   let class_name = CAst_utils.get_qualified_name name_info in
   Logging.out_debug "ADDING: ObjCInterfaceDecl for '%s'\n" class_name;
-  let interface_name = Typename.Objc.from_string class_name in
+  let interface_name = Typ.Name.Objc.from_string class_name in
   let decl_key = `DeclPtr decl_info.Clang_ast_t.di_pointer in
   CAst_utils.update_sil_types_map decl_key (Typ.Tstruct interface_name);
   let decl_supers, decl_fields =
@@ -89,7 +89,7 @@ let add_class_to_tenv type_ptr_to_sil_type tenv decl_info name_info decl_list oc
       Logging.out_debug "----->SuperClass field: '%s' " (Ident.fieldname_to_string fn);
       Logging.out_debug "type: '%s'\n" (Typ.to_string ft)) fields_sc;
   (*In case we found categories, or partial definition of this class earlier and they are already in the tenv *)
-  let fields, (supers : Typename.t list) =
+  let fields, (supers : Typ.Name.t list) =
     match Tenv.lookup tenv interface_name with
     | Some { fields; supers} ->
         CGeneral_utils.append_no_duplicates_fields decl_fields fields,
@@ -107,7 +107,7 @@ let add_class_to_tenv type_ptr_to_sil_type tenv decl_info name_info decl_list oc
     Tenv.mk_struct tenv
       ~fields: all_fields ~supers ~methods:[] ~annots:Annot.Class.objc interface_name );
   Logging.out_debug
-    "  >>>Verifying that Typename '%s' is in tenv\n" (Typename.to_string interface_name);
+    "  >>>Verifying that Typename '%s' is in tenv\n" (Typ.Name.to_string interface_name);
   (match Tenv.lookup tenv interface_name with
    | Some st ->
        Logging.out_debug "  >>>OK. Found typ='%a'\n"
@@ -140,7 +140,7 @@ let interface_impl_declaration type_ptr_to_sil_type tenv decl =
       let _ = add_class_decl type_ptr_to_sil_type tenv idi in
       let fields = CField_decl.get_fields type_ptr_to_sil_type tenv decl_list in
       CField_decl.add_missing_fields tenv class_name fields;
-      let class_tn_name = Typename.Objc.from_string class_name in
+      let class_tn_name = Typ.Name.Objc.from_string class_name in
       let decl_key = `DeclPtr decl_info.Clang_ast_t.di_pointer in
       let class_typ = Typ.Tstruct class_tn_name in
       CAst_utils.update_sil_types_map decl_key class_typ;
diff --git a/infer/src/clang/objcProtocol_decl.ml b/infer/src/clang/objcProtocol_decl.ml
index ef4f0b07d..108087bea 100644
--- a/infer/src/clang/objcProtocol_decl.ml
+++ b/infer/src/clang/objcProtocol_decl.ml
@@ -25,7 +25,7 @@ let protocol_decl type_ptr_to_sil_type tenv decl =
       (* Here we are giving a similar treatment as interfaces (see above)*)
       (* It may turn out that we need a more specific treatment for protocols*)
       Logging.out_debug "ADDING: ObjCProtocolDecl for '%s'\n" name;
-      let protocol_name = Typename.Objc.protocol_from_string name in
+      let protocol_name = Typ.Name.Objc.protocol_from_string name in
       let decl_key = `DeclPtr decl_info.Clang_ast_t.di_pointer in
       CAst_utils.update_sil_types_map decl_key (Typ.Tstruct protocol_name);
       ignore( Tenv.mk_struct tenv ~methods:[] protocol_name );
diff --git a/infer/src/eradicate/eradicateChecks.ml b/infer/src/eradicate/eradicateChecks.ml
index 0cb852a56..f2c1a08e8 100644
--- a/infer/src/eradicate/eradicateChecks.ml
+++ b/infer/src/eradicate/eradicateChecks.ml
@@ -118,8 +118,8 @@ let check_condition tenv case_zero find_canonical_duplicate curr_pdesc
     let loc = Procdesc.Node.get_loc node in
     let throwable_found = ref false in
     let typ_is_throwable = function
-      | Typ.Tstruct (TN_csu (Class Java, _) as name) ->
-          String.equal (Typename.name name) "java.lang.Throwable"
+      | Typ.Tstruct (TN_csu (Class Java, _, _) as name) ->
+          String.equal (Typ.Name.name name) "java.lang.Throwable"
       | _ -> false in
     let do_instr = function
       | Sil.Call (_, Exp.Const (Const.Cfun pn), [_; (Exp.Sizeof(t, _, _), _)], _, _) when
@@ -289,7 +289,7 @@ let check_constructor_initialization tenv
               let should_check_field_initialization =
                 let in_current_class =
                   let fld_cname = Ident.java_fieldname_get_class fn in
-                  String.equal (Typename.name name) fld_cname in
+                  String.equal (Typ.Name.name name) fld_cname in
                 not injector_readonly_annotated &&
                 PatternMatch.type_is_class ft &&
                 in_current_class &&
diff --git a/infer/src/harness/androidFramework.ml b/infer/src/harness/androidFramework.ml
index f62d445cc..c586bdb6c 100644
--- a/infer/src/harness/androidFramework.ml
+++ b/infer/src/harness/androidFramework.ml
@@ -58,7 +58,7 @@ let android_lifecycles =
 
 let is_subtype_package_class tenv tname package classname =
   PatternMatch.is_subtype tenv
-    tname (Typename.Java.from_package_class package classname)
+    tname (Typ.Name.Java.from_package_class package classname)
 
 let is_context tenv tname =
   is_subtype_package_class tenv tname "android.content" "Context"
@@ -78,7 +78,7 @@ let is_fragment tenv tname =
 
 (** return true if [class_name] is the name of a class that belong to the Android framework *)
 let is_android_lib_class class_name =
-  let class_str = Typename.name class_name in
+  let class_str = Typ.Name.name class_name in
   String.is_prefix ~prefix:"android" class_str || String.is_prefix ~prefix:"com.android" class_str
 
 (** given an Android framework type mangled string [lifecycle_typ] (e.g., android.app.Activity) and
diff --git a/infer/src/harness/androidFramework.mli b/infer/src/harness/androidFramework.mli
index bb6a212dc..bc28f868b 100644
--- a/infer/src/harness/androidFramework.mli
+++ b/infer/src/harness/androidFramework.mli
@@ -15,25 +15,25 @@ open! IStd
 val get_lifecycles : (string * string * string list) list
 
 (** return true if [typename] <: android.content.Context *)
-val is_context : Tenv.t -> Typename.t -> bool
+val is_context : Tenv.t -> Typ.Name.t -> bool
 
 (** return true if [typename] <: android.app.Application *)
-val is_application : Tenv.t -> Typename.t -> bool
+val is_application : Tenv.t -> Typ.Name.t -> bool
 
 (** return true if [typename] <: android.app.Activity *)
-val is_activity : Tenv.t -> Typename.t -> bool
+val is_activity : Tenv.t -> Typ.Name.t -> bool
 
 (** return true if [typename] <: android.view.View *)
-val is_view : Tenv.t -> Typename.t -> bool
+val is_view : Tenv.t -> Typ.Name.t -> bool
 
-val is_fragment : Tenv.t -> Typename.t -> bool
+val is_fragment : Tenv.t -> Typ.Name.t -> bool
 
 (** return true if [procname] is a special lifecycle cleanup method *)
 val is_destroy_method : Typ.Procname.t -> bool
 
 (** given an Android framework type mangled string [lifecycle_typ] (e.g., android.app.Activity)
     and a list of method names [lifecycle_procs_strs], get the appropriate typ and procnames *)
-val get_lifecycle_for_framework_typ_opt : Tenv.t -> Typename.t -> string list -> Typ.Procname.t list
+val get_lifecycle_for_framework_typ_opt : Tenv.t -> Typ.Name.t -> string list -> Typ.Procname.t list
 
 (** return true if [class_name] is the name of a class that belong to the Android framework *)
-val is_android_lib_class : Typename.t -> bool
+val is_android_lib_class : Typ.Name.t -> bool
diff --git a/infer/src/harness/harness.ml b/infer/src/harness/harness.ml
index b1ea18d3c..f30a90b18 100644
--- a/infer/src/harness/harness.ml
+++ b/infer/src/harness/harness.ml
@@ -18,7 +18,7 @@ module F = Format
     constituting a lifecycle trace *)
 let try_create_lifecycle_trace name lifecycle_name lifecycle_procs tenv =
   match name with
-  | Typename.TN_csu (Class Java, _) ->
+  | Typ.TN_csu (Class Java, _, _) ->
       if PatternMatch.is_subtype tenv name lifecycle_name &&
          not (AndroidFramework.is_android_lib_class name) then
         let ptr_to_struct_typ = Some (Typ.Tptr (Tstruct name, Pk_pointer)) in
@@ -37,7 +37,7 @@ let try_create_lifecycle_trace name lifecycle_name lifecycle_procs tenv =
 (** generate a harness for a lifecycle type in an Android application *)
 let create_harness cfg cg tenv =
   List.iter ~f:(fun (pkg, clazz, lifecycle_methods) ->
-      let typname = Typename.Java.from_package_class pkg clazz in
+      let typname = Typ.Name.Java.from_package_class pkg clazz in
       let framework_procs =
         AndroidFramework.get_lifecycle_for_framework_typ_opt tenv typname lifecycle_methods in
       (* iterate through the type environment and generate a lifecycle harness for each
@@ -49,11 +49,11 @@ let create_harness cfg cg tenv =
           | [] -> ()
           | lifecycle_trace ->
               let harness_procname =
-                let harness_cls_name = Typename.name name in
+                let harness_cls_name = Typ.Name.name name in
                 let pname =
                   Typ.Procname.Java
                     (Typ.Procname.java
-                       (Typename.Java.from_string harness_cls_name) None
+                       (Typ.Name.Java.from_string harness_cls_name) None
                        "InferGeneratedHarness" [] Typ.Procname.Static) in
                 match pname with
                 | Typ.Procname.Java harness_procname -> harness_procname
diff --git a/infer/src/harness/inhabit.ml b/infer/src/harness/inhabit.ml
index 200a09344..b57bfa2c7 100644
--- a/infer/src/harness/inhabit.ml
+++ b/infer/src/harness/inhabit.ml
@@ -98,7 +98,7 @@ let rec inhabit_typ tenv typ cfg env =
             match typ with
             | Tstruct name -> (
                 match name, Tenv.lookup tenv name with
-                | TN_csu (Class _, _), Some { methods } ->
+                | TN_csu (Class _, _, _), Some { methods } ->
                     let is_suitable_constructor p =
                       let try_get_non_receiver_formals p =
                         get_non_receiver_formals (formals_from_name cfg p) in
diff --git a/infer/src/java/jTransType.ml b/infer/src/java/jTransType.ml
index 19b6df8b6..01c3ed6fc 100644
--- a/infer/src/java/jTransType.ml
+++ b/infer/src/java/jTransType.ml
@@ -58,7 +58,7 @@ let const_type const =
 
 
 let typename_of_classname cn =
-  Typename.Java.from_string (JBasics.cn_name cn)
+  Typ.Name.Java.from_string (JBasics.cn_name cn)
 
 
 let rec get_named_type vt =
@@ -88,8 +88,8 @@ let rec create_array_type typ dim =
 
 let extract_cn_no_obj typ =
   match typ with
-  | Typ.Tptr (Tstruct (TN_csu (Class _, _) as name), Pk_pointer) ->
-      let class_name = JBasics.make_cn (Typename.name name) in
+  | Typ.Tptr (Tstruct (TN_csu (Class _, _, _) as name), Pk_pointer) ->
+      let class_name = JBasics.make_cn (Typ.Name.name name) in
       if JBasics.cn_equal class_name JBasics.java_lang_object then None
       else
         let jbir_class_name = class_name in
@@ -193,7 +193,7 @@ let get_method_kind m =
 
 let get_method_procname cn ms method_kind =
   let return_type_name, method_name, args_type_name = method_signature_names ms in
-  let class_name = Typename.Java.from_string (JBasics.cn_name cn) in
+  let class_name = Typ.Name.Java.from_string (JBasics.cn_name cn) in
   let proc_name_java =
     Typ.Procname.java class_name return_type_name method_name args_type_name method_kind in
   Typ.Procname.Java proc_name_java
diff --git a/infer/src/java/jTransType.mli b/infer/src/java/jTransType.mli
index 33adf5b6c..7b437dc54 100644
--- a/infer/src/java/jTransType.mli
+++ b/infer/src/java/jTransType.mli
@@ -17,7 +17,7 @@ open Sawja_pack
 val get_named_type : JBasics.value_type -> Typ.t
 
 (** transforms a Java class name into a Sil class name *)
-val typename_of_classname : JBasics.class_name -> Typename.t
+val typename_of_classname : JBasics.class_name -> Typ.Name.t
 
 (** returns a name for a field based on a class name and a field name  *)
 val create_fieldname : JBasics.class_name -> JBasics.field_signature -> Ident.fieldname
diff --git a/infer/src/quandary/JavaTaintAnalysis.ml b/infer/src/quandary/JavaTaintAnalysis.ml
index 6259e9059..e4c6f3565 100644
--- a/infer/src/quandary/JavaTaintAnalysis.ml
+++ b/infer/src/quandary/JavaTaintAnalysis.ml
@@ -28,7 +28,7 @@ include
         | Typ.Tptr (Tstruct original_typename, _) ->
             PatternMatch.supertype_exists
               tenv
-              (fun typename _ -> String.equal (Typename.name typename) class_string)
+              (fun typename _ -> String.equal (Typ.Name.name typename) class_string)
               original_typename
         | _ ->
             false in
diff --git a/infer/src/quandary/JavaTrace.ml b/infer/src/quandary/JavaTrace.ml
index e315b9e13..aa24b0135 100644
--- a/infer/src/quandary/JavaTrace.ml
+++ b/infer/src/quandary/JavaTrace.ml
@@ -47,7 +47,7 @@ module SourceKind = struct
               Some Other
           | class_name, method_name ->
               let taint_matching_supertype typename _ =
-                match Typename.name typename, method_name with
+                match Typ.Name.name typename, method_name with
                 | "android.app.Activity", "getIntent" ->
                     Some Intent
                 | "android.content.Intent", "getStringExtra" ->
@@ -60,7 +60,7 @@ module SourceKind = struct
                 PatternMatch.supertype_find_map_opt
                   tenv
                   taint_matching_supertype
-                  (Typename.Java.from_string class_name) in
+                  (Typ.Name.Java.from_string class_name) in
               begin
                 match kind_opt with
                 | Some _ -> kind_opt
@@ -85,7 +85,7 @@ module SourceKind = struct
       let taint_formal_with_types ((formal_name, formal_typ) as formal) =
         let matches_classname = match formal_typ with
           | Typ.Tptr (Tstruct typename, _) ->
-              List.mem ~equal:String.equal type_strs (Typename.name typename)
+              List.mem ~equal:String.equal type_strs (Typ.Name.name typename)
           | _ ->
               false in
         if matches_classname
@@ -104,7 +104,7 @@ module SourceKind = struct
               taint_formals_with_types ["java.lang.Integer"; "java.lang.String"] Other formals
           | class_name, method_name ->
               let taint_matching_supertype typename _ =
-                match Typename.name typename, method_name with
+                match Typ.Name.name typename, method_name with
                 | "android.app.Activity", ("onActivityResult" | "onNewIntent") ->
                     Some (taint_formals_with_types ["android.content.Intent"] Intent formals)
                 | _ ->
@@ -114,7 +114,7 @@ module SourceKind = struct
                   PatternMatch.supertype_find_map_opt
                     tenv
                     taint_matching_supertype
-                    (Typename.Java.from_string class_name) with
+                    (Typ.Name.Java.from_string class_name) with
                 | Some tainted_formals -> tainted_formals
                 | None -> Source.all_formals_untainted pdesc
               end
@@ -174,7 +174,7 @@ module SinkKind = struct
               [Other, 0, false]
           | class_name, method_name ->
               let taint_matching_supertype typename _ =
-                match Typename.name typename, method_name with
+                match Typ.Name.name typename, method_name with
                 | "android.app.Activity",
                   ("startActivityFromChild" | "startActivityFromFragment") ->
                     Some (taint_nth 1 Intent ~report_reachable:true)
@@ -240,7 +240,7 @@ module SinkKind = struct
                   PatternMatch.supertype_find_map_opt
                     tenv
                     taint_matching_supertype
-                    (Typename.Java.from_string class_name) with
+                    (Typ.Name.Java.from_string class_name) with
                 | Some sinks -> sinks
                 | None -> []
               end