Merge branch 'dev' of super:otp into dev

* 'dev' of super:otp: (166 commits)
  Corrected documentation error and added examples to Users Guide
  In TLS 1.1, failure to properly close a connection no longer requires that a session not be resumed.  This is a change from TLS 1.0 to conform with widespread implementation practice.  Erlang ssl will now in TLS 1.0 conform to the widespread implementation practice instead of the specification to avoid performance issues.
  Add escript to bootstrap/bin
  Remove unused variable warning in inet_res
  Remove unused variable in epmd_port
  Remove compiler warnings in inet_drv
  Add SASL test suite
  Allow same module name in multiple applications if explicitely excluded
  Fix bugs concerning the option report_missing_types
  Fix default encoding in SAX parser.
  re: remove gratuitous "it " in manpage
  Spelling in (backward *compatibility*) comment.
  Improve erl_docgen's support for Dialyzer specs and types
  dialyzer warning on mnesia_tm
  Add documentation text about majority checking
  add mnesia_majority_test suite
  where_to_wlock optimization + change_table_majority/2
  bug in mnesia_tm:needs_majority/2
  optimize sticky_lock maj. check
  check majority for sticky locks
  ...

1 files changed, 124 insertions, 48 deletions

diff --git a/lib/kernel/src/application.erl b/lib/kernel/src/application.erl
index 2a193affd4..fa3a4c3d36 100644
--- a/lib/kernel/src/application.erl
+++ b/lib/kernel/src/application.erl
@@ -32,20 +32,30 @@
 
 %%%-----------------------------------------------------------------
 
+-type start_type() :: 'normal'
+                    | {'takeover', Node :: node()}
+                    | {'failover', Node :: node()}.
 -type restart_type() :: 'permanent' | 'transient' | 'temporary'.
--type application_opt() :: {'description', string()}
-                         | {'vsn', string()}
-                         | {'id', string()}
-                         | {'modules', [atom() | {atom(), any()}]} 
-                         | {'registered', [atom()]}
-                         | {'applications', [atom()]}
-                         | {'included_applications', [atom()]}
-                         | {'env', [{atom(), any()}]}
-                         | {'start_phases', [{atom(), any()}] | 'undefined'}
-                         | {'maxT', timeout()}                % max timeout
-                         | {'maxP', integer() | 'infinity'}   % max processes
-                         | {'mod', {atom(), any()}}.
--type application_spec() :: {'application', atom(), [application_opt()]}.
+-type application_opt() :: {'description', Description :: string()}
+                         | {'vsn', Vsn :: string()}
+                         | {'id', Id :: string()}
+                         | {'modules', [(Module :: module()) |
+                                        {Module :: module(), Version :: term()}]}
+                         | {'registered', Names :: [Name :: atom()]}
+                         | {'applications', [Application :: atom()]}
+                         | {'included_applications', [Application :: atom()]}
+                         | {'env', [{Par :: atom(), Val :: term()}]}
+                         | {'start_phases',
+                            [{Phase :: atom(), PhaseArgs :: term()}] | 'undefined'}
+                         | {'maxT', MaxT :: timeout()}          % max timeout
+                         | {'maxP',
+                            MaxP :: pos_integer() | 'infinity'} % max processes
+                         | {'mod', Start :: {Module :: module(), StartArgs :: term()}}.
+-type application_spec() :: {'application',
+                             Application :: atom(),
+                             AppSpecKeys :: [application_opt()]}.
+
+-type(tuple_of(_T) :: tuple()).
 
 %%------------------------------------------------------------------
 
@@ -61,16 +71,29 @@ behaviour_info(_Other) ->
 %%% application_master.
 %%%-----------------------------------------------------------------
 
--spec load(Application :: atom() | application_spec()) ->
-	     'ok' | {'error', term()}.
+-spec load(AppDescr) -> 'ok' | {'error', Reason} when
+      AppDescr :: Application | (AppSpec :: application_spec()),
+      Application :: atom(),
+      Reason :: term().
 
 load(Application) ->
-    load(Application, []).
-
--spec load(Application :: atom() | application_spec(),
-	   Distributed :: any()) -> 'ok' | {'error', term()}.
+    load1(Application, []).
+
+-spec load(AppDescr, Distributed) -> 'ok' | {'error', Reason} when
+      AppDescr :: Application | (AppSpec :: application_spec()),
+      Application :: atom(),
+      Distributed :: {Application,Nodes}
+                   | {Application,Time,Nodes}
+                   | 'default',
+      Nodes :: [node() | tuple_of(node())],
+      Time :: pos_integer(),
+      Reason :: term().
 
 load(Application, DistNodes) ->
+    load1(Application, DistNodes).
+
+%% Workaround due to specs.
+load1(Application, DistNodes) ->
     case application_controller:load_application(Application) of
 	ok when DistNodes =/= [] ->
 	    AppName = get_appl_name(Application),
@@ -85,18 +108,24 @@ load(Application, DistNodes) ->
 	    Else
     end.
 
--spec unload(Application :: atom()) -> 'ok' | {'error', term()}.
+-spec unload(Application) -> 'ok' | {'error', Reason} when
+      Application :: atom(),
+      Reason :: term().
 
 unload(Application) ->
     application_controller:unload_application(Application).
 
--spec start(Application :: atom()) -> 'ok' | {'error', term()}.
+-spec start(Application) -> 'ok' | {'error', Reason} when
+      Application :: atom(),
+      Reason :: term().
 
 start(Application) ->
     start(Application, temporary).
 
--spec start(Application :: atom() | application_spec(),
-	    RestartType :: restart_type()) -> any().
+-spec start(Application, Type) -> 'ok' | {'error', Reason} when
+      Application :: atom(),
+      Type :: restart_type(),
+      Reason :: term().
 
 start(Application, RestartType) ->
     case load(Application) of
@@ -120,12 +149,18 @@ start_boot(Application) ->
 start_boot(Application, RestartType) ->
     application_controller:start_boot_application(Application, RestartType).
 
--spec takeover(Application :: atom(), RestartType :: restart_type()) -> any().
+-spec takeover(Application, Type) -> 'ok' | {'error', Reason} when
+      Application :: atom(),
+      Type :: restart_type(),
+      Reason :: term().
 
 takeover(Application, RestartType) ->
     dist_ac:takeover_application(Application, RestartType).
 
--spec permit(Application :: atom(), Bool :: boolean()) -> 'ok' | {'error', term()}.
+-spec permit(Application, Permission) -> 'ok' | {'error', Reason} when
+      Application :: atom(),
+      Permission :: boolean(),
+      Reason :: term().
 
 permit(Application, Bool) ->
     case Bool of
@@ -142,105 +177,146 @@ permit(Application, Bool) ->
 	    LocalResult
     end.
 
--spec stop(Application :: atom()) -> 'ok' | {'error', term()}.
+-spec stop(Application) -> 'ok' | {'error', Reason} when
+      Application :: atom(),
+      Reason :: term().
 
 stop(Application) ->
     application_controller:stop_application(Application).
 
--spec which_applications() -> [{atom(), string(), string()}].
+-spec which_applications() -> [{Application, Description, Vsn}] when
+      Application :: atom(),
+      Description :: string(),
+      Vsn :: string().
 
 which_applications() ->
     application_controller:which_applications().
 
--spec which_applications(timeout()) -> [{atom(), string(), string()}].
+-spec which_applications(Timeout) -> [{Application, Description, Vsn}] when
+      Timeout :: timeout(),
+      Application :: atom(),
+      Description :: string(),
+      Vsn :: string().
 
 which_applications(infinity) ->
     application_controller:which_applications(infinity);
 which_applications(Timeout) when is_integer(Timeout), Timeout>=0 ->
     application_controller:which_applications(Timeout).
 
--spec loaded_applications() -> [{atom(), string(), string()}].
+-spec loaded_applications() -> [{Application, Description, Vsn}] when
+      Application :: atom(),
+      Description :: string(),
+      Vsn :: string().
 
 loaded_applications() -> 
     application_controller:loaded_applications().
 
--spec info() -> any().
+-spec info() -> term().
 
 info() -> 
     application_controller:info().
 
--spec set_env(Application :: atom(), Key :: atom(), Value :: any()) -> 'ok'.
+-spec set_env(Application, Par, Val) -> 'ok' when
+      Application :: atom(),
+      Par :: atom(),
+      Val :: term().
 
 set_env(Application, Key, Val) -> 
     application_controller:set_env(Application, Key, Val).
 
--spec set_env(Application :: atom(), Key :: atom(),
-	      Value :: any(), Timeout :: timeout()) -> 'ok'.
+-spec set_env(Application, Par, Val, Timeout) -> 'ok' when
+      Application :: atom(),
+      Par :: atom(),
+      Val :: term(),
+      Timeout :: timeout().
 
 set_env(Application, Key, Val, infinity) ->
     application_controller:set_env(Application, Key, Val, infinity);
 set_env(Application, Key, Val, Timeout) when is_integer(Timeout), Timeout>=0 ->
     application_controller:set_env(Application, Key, Val, Timeout).
 
--spec unset_env(atom(), atom()) -> 'ok'.
+-spec unset_env(Application, Par) -> 'ok' when
+      Application :: atom(),
+      Par :: atom().
 
 unset_env(Application, Key) -> 
     application_controller:unset_env(Application, Key).
 
--spec unset_env(atom(), atom(), timeout()) -> 'ok'.
+-spec unset_env(Application, Par, Timeout) -> 'ok' when
+      Application :: atom(),
+      Par :: atom(),
+      Timeout :: timeout().
 
 unset_env(Application, Key, infinity) ->
     application_controller:unset_env(Application, Key, infinity);
 unset_env(Application, Key, Timeout) when is_integer(Timeout), Timeout>=0 ->
     application_controller:unset_env(Application, Key, Timeout).
 
--spec get_env(atom()) -> 'undefined' | {'ok', term()}.
+-spec get_env(Par) -> 'undefined' | {'ok', Val} when
+      Par :: atom(),
+      Val :: term().
 
 get_env(Key) -> 
     application_controller:get_pid_env(group_leader(), Key).
 
--spec get_env(atom(), atom()) -> 'undefined' | {'ok', term()}.
+-spec get_env(Application, Par) -> 'undefined' | {'ok', Val} when
+      Application :: atom(),
+      Par :: atom(),
+      Val :: term().
 
 get_env(Application, Key) -> 
     application_controller:get_env(Application, Key).
 
--spec get_all_env() -> [{atom(), any()}].
+-spec get_all_env() -> Env when
+      Env :: [{Par :: atom(), Val :: term()}].
 
 get_all_env() -> 
     application_controller:get_pid_all_env(group_leader()).
 
--spec get_all_env(atom()) -> [{atom(), any()}].
+-spec get_all_env(Application) -> Env when
+      Application :: atom(),
+      Env :: [{Par :: atom(), Val :: term()}].
 
 get_all_env(Application) -> 
     application_controller:get_all_env(Application).
 
--spec get_key(atom()) -> 'undefined' | {'ok', term()}.
+-spec get_key(Key) -> 'undefined' | {'ok', Val} when
+      Key :: atom(),
+      Val :: term().
 
 get_key(Key) -> 
     application_controller:get_pid_key(group_leader(), Key).
 
--spec get_key(atom(), atom()) -> 'undefined' | {'ok', term()}.
+-spec get_key(Application, Key) -> 'undefined' | {'ok', Val} when
+      Application :: atom(),
+      Key :: atom(),
+      Val :: term().
 
 get_key(Application, Key) -> 
     application_controller:get_key(Application, Key).
 
--spec get_all_key() -> 'undefined' | [] | {'ok', [{atom(),any()},...]}.
+-spec get_all_key() -> [] | {'ok', Keys} when
+      Keys :: [{Key :: atom(),Val :: term()},...].
 
 get_all_key() ->
     application_controller:get_pid_all_key(group_leader()).
 
--spec get_all_key(atom()) -> 'undefined' | {'ok', [{atom(),any()},...]}.
+-spec get_all_key(Application) -> 'undefined' | Keys when
+      Application :: atom(),
+      Keys :: {'ok', [{Key :: atom(),Val :: term()},...]}.
 
 get_all_key(Application) -> 
     application_controller:get_all_key(Application).
 
--spec get_application() -> 'undefined' | {'ok', atom()}.
+-spec get_application() -> 'undefined' | {'ok', Application} when
+      Application :: atom().
 
 get_application() -> 
     application_controller:get_application(group_leader()).
 
--spec get_application(Pid :: pid()) -> 'undefined' | {'ok', atom()}
-		   ; (Module :: atom()) -> 'undefined' | {'ok', atom()}.
+-spec get_application(PidOrModule) -> 'undefined' | {'ok', Application} when
+      PidOrModule :: (Pid :: pid()) | (Module :: module()),
+      Application :: atom().
 
 get_application(Pid) when is_pid(Pid) ->
     case process_info(Pid, group_leader) of
@@ -252,8 +328,8 @@ get_application(Pid) when is_pid(Pid) ->
 get_application(Module) when is_atom(Module) ->
     application_controller:get_application_module(Module).
 
--spec start_type() -> 'undefined' | 'local' | 'normal'
-		    | {'takeover', node()} | {'failover', node()}.
+-spec start_type() -> StartType | 'undefined' | 'local' when
+      StartType :: start_type().
 
 start_type() ->
     application_controller:start_type(group_leader()).