Merge branch 'hb/stdlib/refine_abstr_types/OTP-10292'

* hb/stdlib/refine_abstr_types/OTP-10292:
  erts: Improve readability of The Abstract Format
  erts: Improve the documentation of the abstract format
  stdlib: Update erl_parse(3)
  stdlib: Refine the types of the abstract format
  compiler: Improve type and specs
  hipe: Improve types
  dialyzer: Improve a type
  doc: Update a refman example
  syntax_tools: Correct a type
  stdlib: Correct a type

9 files changed, 545 insertions, 81 deletions

diff --git a/lib/compiler/src/compile.erl b/lib/compiler/src/compile.erl
index b61c104b3c..72f1a767ed 100644
--- a/lib/compiler/src/compile.erl
+++ b/lib/compiler/src/compile.erl
@@ -40,6 +40,8 @@
 
 %%----------------------------------------------------------------------
 
+-type abstract_code() :: [erl_parse:abstract_form()].
+
 -type option() :: atom() | {atom(), term()} | {'d', atom(), term()}.
 
 -type err_info() :: {erl_anno:line() | 'none',
@@ -48,6 +50,9 @@
 -type warnings() :: [{file:filename(), [err_info()]}].
 -type mod_ret()  :: {'ok', module()}
                   | {'ok', module(), cerl:c_module()} %% with option 'to_core'
+                  | {'ok',                            %% with option 'to_pp'
+                     module() | [],                   %% module() if 'to_exp'
+                     abstract_code()}
                   | {'ok', module(), warnings()}.
 -type bin_ret()  :: {'ok', module(), binary()}
                   | {'ok', module(), binary(), warnings()}.
@@ -78,7 +83,11 @@ file(File, Opts) when is_list(Opts) ->
 file(File, Opt) ->
     file(File, [Opt|?DEFAULT_OPTIONS]).
 
-forms(File) -> forms(File, ?DEFAULT_OPTIONS).
+-spec forms(abstract_code()) -> comp_ret().
+
+forms(Forms) -> forms(Forms, ?DEFAULT_OPTIONS).
+
+-spec forms(abstract_code(), [option()] | option()) -> comp_ret().
 
 forms(Forms, Opts) when is_list(Opts) ->
     do_compile({forms,Forms}, [binary|Opts++env_default_opts()]);
@@ -106,6 +115,8 @@ noenv_file(File, Opts) when is_list(Opts) ->
 noenv_file(File, Opt) ->
     noenv_file(File, [Opt|?DEFAULT_OPTIONS]).
 
+-spec noenv_forms(abstract_code(), [option()] | option()) -> comp_ret().
+
 noenv_forms(Forms, Opts) when is_list(Opts) ->
     do_compile({forms,Forms}, [binary|Opts]);
 noenv_forms(Forms, Opt) when is_atom(Opt) ->
diff --git a/lib/dialyzer/src/dialyzer_utils.erl b/lib/dialyzer/src/dialyzer_utils.erl
index 7fe982a992..557e10eed7 100644
--- a/lib/dialyzer/src/dialyzer_utils.erl
+++ b/lib/dialyzer/src/dialyzer_utils.erl
@@ -83,7 +83,7 @@ print_types1([{record, _Name} = Key|T], RecDict) ->
 
 %% ----------------------------------------------------------------------------
 
--type abstract_code() :: [tuple()]. %% XXX: import from somewhere
+-type abstract_code() :: [erl_parse:abstract_form()].
 -type comp_options()  :: [compile:option()].
 -type mod_or_fname()  :: module() | file:filename().
 -type fa()            :: {atom(), arity()}.
diff --git a/lib/hipe/cerl/erl_types.erl b/lib/hipe/cerl/erl_types.erl
index 67cdcd35e3..69654088d5 100644
--- a/lib/hipe/cerl/erl_types.erl
+++ b/lib/hipe/cerl/erl_types.erl
@@ -316,7 +316,7 @@
 %% Auxiliary types and convenient macros
 %%
 
--type parse_form() :: {atom(), _, _} | {atom(), _, _, _} | {'op', _, _, _, _}. %% XXX: Temporarily
+-type parse_form() :: erl_parse:abstract_expr().
 -type rng_elem()   :: 'pos_inf' | 'neg_inf' | integer().
 
 -record(int_set, {set :: [integer()]}).
@@ -365,8 +365,8 @@
 -type type_key()     :: {'type' | 'opaque', atom(), arity()}.
 -type record_value() :: [{atom(), erl_parse:abstract_expr(), erl_type()}].
 -type type_value()   :: {module(), erl_type(), atom()}.
--type type_table() :: dict:dict(record_key(), record_value())
-                    | dict:dict(type_key(), type_value()).
+-type type_table() :: dict:dict(record_key() | type_key(),
+                                record_value() | type_value()).
 
 -type var_table() :: dict:dict(atom(), erl_type()).
 
diff --git a/lib/stdlib/doc/src/erl_parse.xml b/lib/stdlib/doc/src/erl_parse.xml
index 0938b5dec3..13be488c33 100644
--- a/lib/stdlib/doc/src/erl_parse.xml
+++ b/lib/stdlib/doc/src/erl_parse.xml
@@ -4,7 +4,7 @@
 <erlref>
   <header>
     <copyright>
-      <year>1996</year><year>2015</year>
+      <year>1996</year><year>2016</year>
       <holder>Ericsson AB. All Rights Reserved.</holder>
     </copyright>
     <legalnotice>
@@ -44,21 +44,33 @@
   </description>
   <datatypes>
     <datatype>
-      <name name="abstract_clause"></name>
-      <desc><p>Parse tree for Erlang clause.</p>
+      <name>abstract_clause()</name>
+      <desc><p><marker id="type-abstract_clause"/>
+        Abstract form of an Erlang clause.</p>
       </desc>
     </datatype>
     <datatype>
-      <name name="abstract_expr"></name>
-      <desc><p>Parse tree for Erlang expression.</p>
+      <name>abstract_expr()</name>
+      <desc><p><marker id="type-abstract_expr"/>
+        Abstract form of an Erlang expression.</p>
       </desc>
     </datatype>
     <datatype>
-      <name name="abstract_form"></name>
-      <desc><p>Parse tree for Erlang form.</p>
+      <name>abstract_form()</name>
+      <desc><p><marker id="type-abstract_form"/>
+        Abstract form of an Erlang form.</p>
       </desc>
     </datatype>
     <datatype>
+      <name>abstract_type()</name>
+      <desc><p><marker id="type-abstract_type"/>
+        Abstract form of an Erlang type.</p>
+      </desc>
+    </datatype>
+    <datatype>
+      <name name="erl_parse_tree"></name>
+    </datatype>
+    <datatype>
       <name name="error_description"></name>
     </datatype>
     <datatype>
@@ -180,7 +192,7 @@
         <p>Converts the Erlang data structure <c><anno>Data</anno></c> into an
           abstract form of type <c><anno>AbsTerm</anno></c>.</p>
         <p>The <c><anno>Line</anno></c> option is the line that will
-          be assigned to each node of the abstract form.</p>
+          be assigned to each node of <c><anno>AbsTerm</anno></c>.</p>
         <p>The <c><anno>Encoding</anno></c> option is used for
           selecting which integer lists will be considered
           as strings. The default is to use the encoding returned by
@@ -196,47 +208,53 @@
     <func>
       <name name="map_anno" arity="2"/>
       <fsummary>
-        Map a function over the annotations of an abstract form
+        Map a function over the annotations of a <c>erl_parse</c> tree
       </fsummary>
       <desc>
-        <p>Modifies the abstract form <anno>Abstr</anno> by applying
-          <anno>Fun</anno> on every collection of annotations of the
-          abstract form. The abstract form is traversed in a
-          depth-first, left-to-right, fashion.
+        <p>Modifies the <c>erl_parse</c> tree <c><anno>Abstr</anno></c>
+	  by applying <c><anno>Fun</anno></c> on each collection of
+	  annotations of the nodes of the <c>erl_parse</c> tree. The
+	  <c>erl_parse</c> tree is traversed in a depth-first,
+	  left-to-right, fashion.
         </p>
       </desc>
     </func>
     <func>
       <name name="fold_anno" arity="3"/>
       <fsummary>
-        Fold a function over the annotations of an abstract form
+        Fold a function over the annotations of a <c>erl_parse</c> tree
       </fsummary>
       <desc>
-        <p>Updates an accumulator by applying <anno>Fun</anno> on
-          every collection of annotations of the abstract form
-          <anno>Abstr</anno>. The first call to <anno>Fun</anno> has
-          <anno>AccIn</anno> as argument, and the returned accumulator
-          <anno>AccOut</anno> is passed to the next call, and so on.
-          The final value of the accumulator is returned. The abstract
-          form is traversed in a depth-first, left-to-right, fashion.
+        <p>Updates an accumulator by applying <c><anno>Fun</anno></c> on
+          each collection of annotations of the <c>erl_parse</c> tree
+          <c><anno>Abstr</anno></c>. The first call to
+          <c><anno>Fun</anno></c> has <c><anno>AccIn</anno></c> as
+          argument, and the returned accumulator
+          <c><anno>AccOut</anno></c> is passed to the next call, and
+          so on. The final value of the accumulator is returned. The
+          <c>erl_parse</c> tree is traversed in a depth-first, left-to-right,
+          fashion.
         </p>
       </desc>
     </func>
     <func>
       <name name="mapfold_anno" arity="3"/>
       <fsummary>
-        Map and fold a function over the annotations of an abstract form
+        Map and fold a function over the annotations of a
+        <c>erl_parse</c> tree
       </fsummary>
       <desc>
-        <p>Modifies the abstract form <anno>Abstr</anno> by applying
-          <anno>Fun</anno> on every collection of annotations of the
-          abstract form, while at the same time updating an
-          accumulator. The first call to <anno>Fun</anno> has
-          <anno>AccIn</anno> as second argument, and the returned
-          accumulator <anno>AccOut</anno> is passed to the next call,
-          and so on. The modified abstract form as well as the the
-          final value of the accumulator is returned. The abstract
-          form is traversed in a depth-first, left-to-right, fashion.
+        <p>Modifies the <c>erl_parse</c> tree <c><anno>Abstr</anno></c>
+	  by applying <c><anno>Fun</anno></c> on each collection of
+	  annotations of the nodes of the <c>erl_parse</c> tree, while
+	  at the same time updating an accumulator. The first call to
+	  <c><anno>Fun</anno></c> has <c><anno>AccIn</anno></c> as
+	  second argument, and the returned accumulator
+	  <c><anno>AccOut</anno></c> is passed to the next call, and
+	  so on. The modified <c>erl_parse</c> tree as well as the the
+	  final value of the accumulator are returned. The
+	  <c>erl_parse</c> tree is traversed in a depth-first,
+	  left-to-right, fashion.
         </p>
       </desc>
     </func>
@@ -246,12 +264,15 @@
         Create new annotations
       </fsummary>
       <desc>
-        <p>Creates an abstract form from a term which has the same
-          structure as an abstract form, but <seealso
-          marker="erl_anno#type-location">locations</seealso> where the
-          abstract form has annotations. For each location, <seealso
-          marker="erl_anno#new/1"><c>erl_anno:new/1</c></seealso> is
-          called, and the annotations replace the location.
+        <p>Assumes that <c><anno>Term</anno></c> is a term with the same
+          structure as a <c>erl_parse</c> tree, but with <seealso
+          marker="erl_anno#type-location">locations</seealso> where a
+          <c>erl_parse</c> tree has collections of annotations.
+          Returns a <c>erl_parse</c> tree where each location <c>L</c>
+          has been replaced by the value returned by <seealso
+          marker="erl_anno#new/1"><c>erl_anno:new(L)</c></seealso>.
+          The term <c><anno>Term</anno></c> is traversed in a
+          depth-first, left-to-right, fashion.
         </p>
       </desc>
     </func>
@@ -261,12 +282,14 @@
         Return annotations as terms
       </fsummary>
       <desc>
-        <p>Assumes that <anno>Term</anno> is a term with the same
-          structure as an abstract form, but with terms, T say, on
-          those places where an abstract form has annotations. Returns
-          an abstract form where every term T has been replaced by the
-          value returned by calling <c>erl_anno:from_term(T)</c>. The
-          term <anno>Term</anno> is traversed in a depth-first,
+        <p>Assumes that <c><anno>Term</anno></c> is a term with the same
+          structure as a <c>erl_parse</c> tree, but with terms,
+          <c>T</c> say, where a <c>erl_parse</c> tree has collections
+          of annotations. Returns a <c>erl_parse</c> tree where each
+          term <c>T</c> has been replaced by the value returned by
+          <seealso marker="erl_anno#from_term/1">
+          <c>erl_anno:from_term(T)</c></seealso>. The term
+          <c><anno>Term</anno></c> is traversed in a depth-first,
           left-to-right, fashion.
         </p>
       </desc>
@@ -277,10 +300,13 @@
         Return the representation of annotations
       </fsummary>
       <desc>
-        <p>Returns a term where every collection of annotations Anno of
-          <anno>Abstr</anno> has been replaced by the term returned by
-          calling <c>erl_anno:to_term(Anno)</c>. The abstract form is
-          traversed in a depth-first, left-to-right, fashion.
+        <p>Returns a term where each collection of annotations
+          <c>Anno</c> of the nodes of the <c>erl_parse</c> tree
+          <c><anno>Abstr</anno></c> has been replaced by the term
+          returned by <seealso marker="erl_anno#to_term/1">
+          <c>erl_anno:to_term(Anno)</c></seealso>. The
+          <c>erl_parse</c> tree is traversed in a depth-first,
+          left-to-right, fashion.
         </p>
       </desc>
     </func>
diff --git a/lib/stdlib/src/erl_lint.erl b/lib/stdlib/src/erl_lint.erl
index 4a42754d92..9ef4acdf5f 100644
--- a/lib/stdlib/src/erl_lint.erl
+++ b/lib/stdlib/src/erl_lint.erl
@@ -696,7 +696,12 @@ set_form_file({function,L,N,A,C}, File) ->
 set_form_file(Form, _File) ->
     Form.
 
+set_file(Ts, File) when is_list(Ts) ->
+    [anno_set_file(T, File) || T <- Ts];
 set_file(T, File) ->
+    anno_set_file(T, File).
+
+anno_set_file(T, File) ->
     F = fun(Anno) -> erl_anno:set_file(File, Anno) end,
     erl_parse:map_anno(F, T).
 
diff --git a/lib/stdlib/src/erl_parse.yrl b/lib/stdlib/src/erl_parse.yrl
index e07ab2efc2..b1c574ea60 100644
--- a/lib/stdlib/src/erl_parse.yrl
+++ b/lib/stdlib/src/erl_parse.yrl
@@ -2,7 +2,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 1996-2015. All Rights Reserved.
+%% Copyright Ericsson AB 1996-2016. All Rights Reserved.
 %%
 %% Licensed under the Apache License, Version 2.0 (the "License");
 %% you may not use this file except in compliance with the License.
@@ -527,12 +527,418 @@ Erlang code.
 -compile([{hipe,[{regalloc,linear_scan}]}]).
 
 -export_type([abstract_clause/0, abstract_expr/0, abstract_form/0,
-              error_info/0]).
+              abstract_type/0, error_info/0]).
+
+%% Start of Abstract Format
+
+-type anno() :: erl_anno:anno().
+
+-type abstract_form() :: af_module()
+                       | af_behavior()
+                       | af_behaviour()
+                       | af_export()
+                       | af_import()
+                       | af_export_type()
+                       | af_optional_callbacks()
+                       | af_compile()
+                       | af_file()
+                       | af_record_decl()
+                       | af_type_decl()
+                       | af_function_spec()
+                       | af_wild_attribute()
+                       | af_function_decl().
+
+-type af_module() :: {'attribute', anno(), 'module', module()}.
+
+-type af_behavior() :: {'attribute', anno(), 'behavior', behaviour()}.
+
+-type af_behaviour() :: {'attribute', anno(), 'behaviour', behaviour()}.
+
+-type behaviour() :: atom().
+
+-type af_export() :: {'attribute', anno(), 'export', af_fa_list()}.
+
+-type af_import() :: {'attribute', anno(), 'import', af_fa_list()}.
+
+-type af_fa_list() :: [{function_name(), arity()}].
+
+-type af_export_type() :: {'attribute', anno(), 'export_type', af_ta_list()}.
+
+-type af_ta_list() :: [{type_name(), arity()}].
+
+-type af_optional_callbacks() ::
+        {'attribute', anno(), 'optional_callbacks', af_fa_list()}.
+
+-type af_compile() :: {'attribute', anno(), 'compile', any()}.
+
+-type af_file() :: {'attribute', anno(), 'file', {string(), anno()}}.
+
+-type af_record_decl() ::
+        {'attribute', anno(), 'record', {record_name(), [af_field_decl()]}}.
+
+-type af_field_decl() :: af_typed_field() | af_field().
+
+-type af_typed_field() ::
+        {'typed_record_field', af_field(), abstract_type()}.
+
+-type af_field() :: {'record_field', anno(), af_field_name()}
+                  | {'record_field', anno(), af_field_name(), abstract_expr()}.
+
+-type af_type_decl() :: {'attribute', anno(), type_attr(),
+                         {type_name(), abstract_type(), [af_variable()]}}.
+
+-type type_attr() :: 'opaque' | 'type'.
+
+-type af_function_spec() :: {'attribute', anno(), spec_attr(),
+                             {{function_name(), arity()},
+                              af_function_type_list()}}
+                          | {'attribute', anno(), 'spec',
+                             {{module(), function_name(), arity()},
+                              af_function_type_list()}}.
+
+-type spec_attr() :: 'callback' | 'spec'.
+
+-type af_wild_attribute() :: {'attribute', anno(), atom(), any()}.
+
+-type af_function_decl() ::
+        {'function', anno(), function_name(), arity(), af_clause_seq()}.
+
+-type abstract_expr() :: af_literal()
+                       | af_match(abstract_expr())
+                       | af_variable()
+                       | af_tuple(abstract_expr())
+                       | af_nil()
+                       | af_cons(abstract_expr())
+                       | af_bin(abstract_expr())
+                       | af_binary_op(abstract_expr())
+                       | af_unary_op(abstract_expr())
+                       | af_record_access(abstract_expr())
+                       | af_record_update(abstract_expr())
+                       | af_record_index()
+                       | af_record_field_access(abstract_expr())
+                       | af_map_access(abstract_expr())
+                       | af_map_update(abstract_expr())
+                       | af_catch()
+                       | af_local_call()
+                       | af_remote_call()
+                       | af_list_comprehension()
+                       | af_binary_comprehension()
+                       | af_block()
+                       | af_if()
+                       | af_case()
+                       | af_try()
+                       | af_receive()
+                       | af_local_fun()
+                       | af_remote_fun()
+                       | af_fun()
+                       | af_named_fun().
+
+-type af_record_update(T) :: {'record',
+                              anno(),
+                              abstract_expr(),
+                              record_name(),
+                              [af_record_field(T)]}.
+
+-type af_catch() :: {'catch', anno(), abstract_expr()}.
+
+-type af_local_call() :: {'call', anno(), af_local_function(), af_args()}.
+
+-type af_remote_call() :: {'call', anno(), af_remote_function(), af_args()}.
+
+-type af_args() :: [abstract_expr()].
+
+-type af_local_function() :: abstract_expr().
+
+-type af_remote_function() ::
+        {'remote', anno(), abstract_expr(), abstract_expr()}.
+
+-type af_list_comprehension() ::
+        {'lc', anno(), af_template(), af_qualifier_seq()}.
+
+-type af_binary_comprehension() ::
+        {'bc', anno(), af_template(), af_qualifier_seq()}.
+
+-type af_template() :: abstract_expr().
+
+-type af_qualifier_seq() :: [af_qualifier()].
+
+-type af_qualifier() :: af_generator() | af_filter().
+
+-type af_generator() :: {'generate', anno(), af_pattern(), abstract_expr()}
+                      | {'b_generate', anno(), af_pattern(), abstract_expr()}.
+
+-type af_filter() :: abstract_expr().
+
+-type af_block() :: {'block', anno(), af_body()}.
+
+-type af_if() :: {'if', anno(), af_clause_seq()}.
+
+-type af_case() :: {'case', anno(), abstract_expr(), af_clause_seq()}.
+
+-type af_try() :: {'try',
+                   anno(),
+                   af_body() | [],
+                   af_clause_seq() | [],
+                   af_clause_seq() | [],
+                   af_body() | []}.
+
+-type af_clause_seq() :: [af_clause(), ...].
+
+-type af_receive() ::
+        {'receive', anno(), af_clause_seq()}
+      | {'receive', anno(), af_clause_seq(), abstract_expr(), af_body()}.
+
+-type af_local_fun() ::
+        {'fun', anno(), {'function', function_name(), arity()}}.
+
+-type af_remote_fun() ::
+        {'fun', anno(), {'function', module(), function_name(), arity()}}
+      | {'fun', anno(), {'function', af_atom(), af_atom(), af_integer()}}.
+
+-type af_fun() :: {'fun', anno(), {'clauses', af_clause_seq()}}.
+
+-type af_named_fun() :: {'named_fun', anno(), fun_name(), af_clause_seq()}.
+
+-type fun_name() :: atom().
+
+-type abstract_clause() :: af_clause().
+
+-type af_clause() ::
+        {'clause', anno(), [af_pattern()], af_guard_seq(), af_body()}.
+
+-type af_body() :: [abstract_expr(), ...].
+
+-type af_guard_seq() :: [af_guard()].
+
+-type af_guard() :: [af_guard_test(), ...].
+
+-type af_guard_test() :: af_literal()
+                       | af_variable()
+                       | af_tuple(af_guard_test())
+                       | af_nil()
+                       | af_cons(af_guard_test())
+                       | af_bin(af_guard_test())
+                       | af_binary_op(af_guard_test())
+                       | af_unary_op(af_guard_test())
+                       | af_record_access(af_guard_test())
+                       | af_record_index()
+                       | af_record_field_access(af_guard_test())
+                       | af_map_access(abstract_expr()) % FIXME
+                       | af_map_update(abstract_expr()) % FIXME
+                       | af_guard_call()
+                       | af_remote_guard_call().
+
+-type af_record_field_access(T) ::
+        {'record_field', anno(), T, record_name(), af_field_name()}.
+
+-type af_map_access(T) :: {'map', anno(), [af_map_field(T)]}.
+
+-type af_map_update(T) :: {'map', anno(), T, [af_map_field(T)]}.
+
+-type af_map_field(T) :: af_map_field_assoc(T) | af_map_field_exact(T).
+
+-type af_map_field_assoc(T) :: {'map_field_assoc', anno(), T, T}.
+
+-type af_map_field_exact(T) :: {'map_field_exact', anno(), T, T}.
+
+-type af_guard_call() :: {'call', anno(), function_name(), [af_guard_test()]}.
+
+-type af_remote_guard_call() ::
+        {'call', anno(),
+         {'remote', anno(), af_lit_atom('erlang'), af_atom()},
+         [af_guard_test()]}.
+
+-type af_pattern() :: af_literal()
+                    | af_match(af_pattern())
+                    | af_variable()
+                    | af_tuple(af_pattern())
+                    | af_nil()
+                    | af_cons(af_pattern())
+                    | af_bin(af_pattern())
+                    | af_binary_op(af_pattern())
+                    | af_unary_op(af_pattern())
+                    | af_record_access(af_pattern())
+                    | af_record_index()
+                    | af_map_pattern().
+
+-type af_record_index() ::
+        {'record_index', anno(), record_name(), af_field_name()}.
+
+-type af_record_access(T) ::
+        {'record', anno(), record_name(), [af_record_field(T)]}.
+
+-type af_record_field(T) :: {'record_field', anno(), af_field_name(), T}.
+
+-type af_map_pattern() ::
+        {'map', anno(), [af_map_field_exact(abstract_expr)]}. % FIXME?
+
+-type abstract_type() :: af_annotated_type()
+                       | af_atom()
+                       | af_bitstring_type()
+                       | af_empty_list_type()
+                       | af_fun_type()
+                       | af_integer_range_type()
+                       | af_map_type()
+                       | af_predefined_type()
+                       | af_record_type()
+                       | af_remote_type()
+                       | af_singleton_integer_type()
+                       | af_tuple_type()
+                       | af_type_union()
+                       | af_type_variable()
+                       | af_user_defined_type().
+
+-type af_annotated_type() ::
+        {'ann_type', anno(), [af_anno() | abstract_type()]}. % [Var, Type]
+
+-type af_anno() :: af_variable().
+
+-type af_bitstring_type() ::
+        {'type', anno(), 'binary', [af_singleton_integer_type()]}.
+
+-type af_empty_list_type() :: {'type', anno(), 'nil', []}.
+
+-type af_fun_type() :: {'type', anno(), 'fun', []}
+                     | {'type', anno(), 'fun', [{'type', anno(), 'any'} |
+                                                abstract_type()]}
+                     | {'type', anno(), 'fun', af_function_type()}.
+
+-type af_integer_range_type() ::
+        {'type', anno(), 'range', [af_singleton_integer_type()]}.
+
+-type af_map_type() :: {'type', anno(), 'map', 'any'}
+                     | {'type', anno(), 'map', [af_map_pair_type()]}.
+
+-type af_map_pair_type() ::
+        {'type', anno(), 'map_field_assoc', [abstract_type()]}.
+
+-type af_predefined_type() ::
+        {'type', anno(), type_name(),  [abstract_type()]}.
+
+-type af_record_type() ::
+        {'type', anno(), 'record', [(Name :: af_atom()) % [Name, T1, ... Tk]
+                                    | af_record_field_type()]}.
+
+-type af_record_field_type() ::
+        {'type', anno(), 'field_type', [(Name :: af_atom()) |
+                                        abstract_type()]}. % [Name, Type]
+
+-type af_remote_type() ::
+        {'remote_type', anno(), [(Module :: af_atom()) |
+                                 (TypeName :: af_atom()) |
+                                 [abstract_type()]]}. % [Module, Name, [T]]
+
+-type af_tuple_type() :: {'type', anno(), 'tuple', 'any'}
+                       | {'type', anno(), 'tuple', [abstract_type()]}.
+
+-type af_type_union() :: {'type', anno(), 'union', [abstract_type()]}.
+
+-type af_type_variable() :: {'var', anno(), atom()}. % except '_'
+
+-type af_user_defined_type() ::
+        {'user_type', anno(), type_name(),  [abstract_type()]}.
+
+-type af_function_type_list() :: [af_constrained_function_type() |
+                                  af_function_type()].
+
+-type af_constrained_function_type() ::
+        {'type', anno(), 'bounded_fun', [af_function_type() | % [Ft, Fc]
+                                         af_function_constraint()]}.
+
+-type af_function_type() ::
+        {'type', anno(), 'fun',
+         [{'type', anno(), 'product', [abstract_type()]} | abstract_type()]}.
+
+-type af_function_constraint() :: [af_constraint()].
+
+-type af_constraint() :: {'type', anno(), 'constraint',
+                          af_lit_atom('is_subtype'),
+                          [af_type_variable() | abstract_type()]}. % [V, T]
+
+-type af_singleton_integer_type() :: af_integer()
+                                   | af_unary_op(af_singleton_integer_type())
+                                   | af_binary_op(af_singleton_integer_type()).
+
+-type af_literal() :: af_atom() | af_integer() | af_float() | af_string().
+
+-type af_atom() :: af_lit_atom(atom()).
+
+-type af_lit_atom(A) :: {'atom', anno(), A}.
+
+-type af_integer() :: {'integer', anno(), non_neg_integer()}.
+
+-type af_float() :: {'float', anno(), float()}.
+
+-type af_string() :: {'string', anno(), string()}.
+
+-type af_match(T) :: {'match', anno(), af_pattern(), T}.
+
+-type af_variable() :: {'var', anno(), atom()}. % | af_anon_variable()
+
+%-type af_anon_variable() :: {'var', anno(), '_'}.
+
+-type af_tuple(T) :: {'tuple', anno(), [T]}.
+
+-type af_nil() :: {'nil', anno()}.
+
+-type af_cons(T) :: {'cons', anno(), T, T}.
+
+-type af_bin(T) :: {'bin', anno(), [af_binelement(T)]}.
+
+-type af_binelement(T) :: {'bin_element',
+                           anno(),
+                           T,
+                           af_binelement_size(),
+                           type_specifier_list()}.
+
+-type af_binelement_size() :: 'default' | abstract_expr().
+
+-type af_binary_op(T) :: {'op', anno(), binary_op(), T, T}.
+
+-type binary_op() :: '/' | '*' | 'div' | 'rem' | 'band' | 'and' | '+' | '-'
+                   | 'bor' | 'bxor' | 'bsl' | 'bsr' | 'or' | 'xor' | '++'
+                   | '--' | '==' | '/=' | '=<' | '<'  | '>=' | '>' | '=:='
+                   | '=/='.
+
+-type af_unary_op(T) :: {'op', anno(), unary_op(), T}.
+
+-type unary_op() :: '+' | '*' | 'bnot' | 'not'.
+
+%% See also lib/stdlib/{src/erl_bits.erl,include/erl_bits.hrl}.
+-type type_specifier_list() :: 'default' | [type_specifier(), ...].
+
+-type type_specifier() :: type()
+                        | signedness()
+                        | endianness()
+                        | unit().
+
+-type type() :: 'integer'
+              | 'float'
+              | 'binary'
+              | 'bytes'
+              | 'bitstring'
+              | 'bits'
+              | 'utf8'
+              | 'utf16'
+              | 'utf32'.
+
+-type signedness() :: 'signed' | 'unsigned'.
+
+-type endianness() :: 'big' | 'little' | 'native'.
+
+-type unit() :: {'unit', 1..256}.
+
+-type record_name() :: atom().
+
+-type af_field_name() :: af_atom().
+
+-type function_name() :: atom().
+
+-type type_name() :: atom().
+
+%% End of Abstract Format
 
 %% XXX. To be refined.
--type abstract_clause() :: term().
--type abstract_expr() :: term().
--type abstract_form() :: term().
 -type error_description() :: term().
 -type error_info() :: {erl_anno:line(), module(), error_description()}.
 -type token() :: erl_scan:token().
@@ -1083,11 +1489,16 @@ type_preop_prec('-') -> {600,700};
 type_preop_prec('bnot') -> {600,700};
 type_preop_prec('#') -> {700,800}.
 
+-type erl_parse_tree() :: abstract_clause()
+                        | abstract_expr()
+                        | abstract_form()
+                        | abstract_type().
+
 -spec map_anno(Fun, Abstr) -> NewAbstr when
       Fun :: fun((Anno) -> Anno),
       Anno :: erl_anno:anno(),
-      Abstr :: abstract_form() | abstract_expr(),
-      NewAbstr :: abstract_form() | abstract_expr().
+      Abstr :: erl_parse_tree(),
+      NewAbstr :: erl_parse_tree().
 
 map_anno(F0, Abstr) ->
     F = fun(A, Acc) -> {F0(A), Acc} end,
@@ -1100,8 +1511,8 @@ map_anno(F0, Abstr) ->
       Acc0 :: term(),
       AccIn :: term(),
       AccOut :: term(),
-      Abstr :: abstract_form() | abstract_expr(),
-      NewAbstr :: abstract_form() | abstract_expr().
+      Abstr :: erl_parse_tree(),
+      NewAbstr :: erl_parse_tree().
 
 fold_anno(F0, Acc0, Abstr) ->
     F = fun(A, Acc) -> {A, F0(A, Acc)} end,
@@ -1115,26 +1526,26 @@ fold_anno(F0, Acc0, Abstr) ->
       Acc1 :: term(),
       AccIn :: term(),
       AccOut :: term(),
-      Abstr :: abstract_form() | abstract_expr(),
-      NewAbstr :: abstract_form() | abstract_expr().
+      Abstr :: erl_parse_tree(),
+      NewAbstr :: erl_parse_tree().
 
 mapfold_anno(F, Acc0, Abstr) ->
     modify_anno1(Abstr, Acc0, F).
 
 -spec new_anno(Term) -> Abstr when
       Term :: term(),
-      Abstr :: abstract_form() | abstract_expr().
+      Abstr :: erl_parse_tree().
 
 new_anno(Term) ->
     map_anno(fun erl_anno:new/1, Term).
 
 -spec anno_to_term(Abstr) -> term() when
-      Abstr :: abstract_form() | abstract_expr().
+      Abstr :: erl_parse_tree().
 
 anno_to_term(Abstract) ->
     map_anno(fun erl_anno:to_term/1, Abstract).
 
--spec anno_from_term(Term) -> abstract_form() | abstract_expr() when
+-spec anno_from_term(Term) -> erl_parse_tree() when
       Term :: term().
 
 anno_from_term(Term) ->
diff --git a/lib/stdlib/src/io.erl b/lib/stdlib/src/io.erl
index 5dc8b4541e..f510f61e9f 100644
--- a/lib/stdlib/src/io.erl
+++ b/lib/stdlib/src/io.erl
@@ -444,7 +444,7 @@ scan_erl_form(Io, Prompt, Pos0, Options) ->
 %% Parsing Erlang code.
 
 -type parse_ret() :: {'ok',
-                      ExprList :: erl_parse:abstract_expr(),
+                      ExprList :: [erl_parse:abstract_expr()],
                       EndLocation :: location()}
                    | {'eof', EndLocation :: location()}
                    | {'error',
diff --git a/lib/stdlib/src/qlc_pt.erl b/lib/stdlib/src/qlc_pt.erl
index 9577d17a85..9f69cd5003 100644
--- a/lib/stdlib/src/qlc_pt.erl
+++ b/lib/stdlib/src/qlc_pt.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2004-2015. All Rights Reserved.
+%% Copyright Ericsson AB 2004-2016. All Rights Reserved.
 %%
 %% Licensed under the Apache License, Version 2.0 (the "License");
 %% you may not use this file except in compliance with the License.
@@ -200,7 +200,7 @@ exclude_integers_from_unique_line_numbers(Forms, NodeInfo) ->
 
 find_integers(Forms) ->
     F = fun(A) ->
-                Fs1 = erl_parse:map_anno(fun(_) -> A end, Forms),
+                Fs1 = map_anno(fun(_) -> A end, Forms),
                 ordsets:from_list(integers(Fs1, []))
         end,
     ordsets:to_list(ordsets:intersection(F(anno0()), F(anno1()))).
@@ -319,13 +319,13 @@ badarg(Forms, State) ->
     E0.
 
 lc_nodes(E, NodeInfo) ->
-    erl_parse:map_anno(fun(Anno) ->
-                               N = erl_anno:line(Anno),
-                               [{N, Data}] = ets:lookup(NodeInfo, N),
-                               NData = Data#{inside_lc => true},
-                               true = ets:insert(NodeInfo, {N, NData}),
-                               Anno
-                       end, E).
+    map_anno(fun(Anno) ->
+                     N = erl_anno:line(Anno),
+                     [{N, Data}] = ets:lookup(NodeInfo, N),
+                     NData = Data#{inside_lc => true},
+                     true = ets:insert(NodeInfo, {N, NData}),
+                     Anno
+             end, E).
 
 used_genvar_messages(MsL, S) ->
     [{File,[{Loc,?APIMOD,{used_generator_variable,V}}]}
@@ -416,7 +416,7 @@ intro_anno(LC, Where, QId, NodeInfo) ->
                   true = ets:insert(NodeInfo, {Location,Data}),
                   Anno
           end,
-    erl_parse:map_anno(Fun, save_anno(LC, NodeInfo)).
+    map_anno(Fun, save_anno(LC, NodeInfo)).
 
 compile_errors(FormsNoShadows) ->
     case compile_forms(FormsNoShadows, []) of
@@ -1650,7 +1650,7 @@ reset_anno(T) ->
     set_anno(T, anno0()).
 
 set_anno(T, A) ->
-    erl_parse:map_anno(fun(_L) -> A end, T).
+    map_anno(fun(_L) -> A end, T).
 
 -record(fstate, {state, bind_fun, imported}).
 
@@ -2609,7 +2609,7 @@ save_anno(Abstr, NodeInfo) ->
                 true = ets:insert(NodeInfo, Data),
                 erl_anno:new(N)
         end,
-    erl_parse:map_anno(F, Abstr).
+    map_anno(F, Abstr).
 
 next_slot(T) ->
     I = ets:update_counter(T, var_n, 1),
@@ -2633,7 +2633,7 @@ restore_anno(Abstr, NodeInfo) ->
                         Anno
                 end
         end,
-    erl_parse:map_anno(F, Abstr).
+    map_anno(F, Abstr).
 
 restore_loc(Location, #state{node_info = NodeInfo}) ->
   case ets:lookup(NodeInfo, Location) of
@@ -2872,6 +2872,14 @@ var_mapfold(F, A0, [E0 | Es0]) ->
 var_mapfold(_F, A, E) ->
     {E, A}.
 
+map_anno(F, AbstrList) when is_list(AbstrList) ->
+    [map_anno1(F, Abstr) || Abstr <- AbstrList];
+map_anno(F, Abstr) ->
+    map_anno1(F, Abstr).
+
+map_anno1(F, Abstr) ->
+    erl_parse:map_anno(F, Abstr).
+
 family_list(L) ->
     sofs:to_external(family(L)).
 
diff --git a/lib/syntax_tools/src/erl_recomment.erl b/lib/syntax_tools/src/erl_recomment.erl
index 72e1e2d2f5..5ce533285d 100644
--- a/lib/syntax_tools/src/erl_recomment.erl
+++ b/lib/syntax_tools/src/erl_recomment.erl
@@ -611,12 +611,15 @@ expand_comment(C) ->
 	       attrs             :: erl_syntax:syntaxTreeAttributes(),
 	       precomments  = [] :: [erl_syntax:syntaxTree()],
 	       postcomments = [] :: [erl_syntax:syntaxTree()],
-	       subtrees     = [] :: [erl_syntax:syntaxTree()]}).
+	       subtrees     = [] :: [extendedSyntaxTree()]}).
+
 
 -record(list, {min = 0           :: integer(),
 	       max = 0           :: integer(),
 	       subtrees = []     :: [erl_syntax:syntaxTree()]}).
 
+-type extendedSyntaxTree() :: #tree{} | #leaf{} | #list{}.
+
 leaf_node(Min, Max, Value) ->
     #leaf{min = Min,
 	  max = Max,