Merge branch 'ks/typer' into dev

* ks/typer: (22 commits)
  Add release notes and up version
  Strengthen some specs
  Allow for --show_success_typings spelling also
  Add '--show_success_typings' option
  Fix crash in oveloaded contracts with overlapping domains
  Fix a type error and do some further cleanup
  Type cleanups and simplifications
  Cleanup the analysis record
  Remove typer_annotator.erl and typer.hrl
  Remove typer_info.erl file
  Remove typer_options.erl file
  Remove typer_preprocess.erl file
  Delete typer_map.erl file, really this time
  Delete typer_map.erl file
  Various cleanups
  Fix Typer's hanging when module name doesn't match filename
  Moved option to its proper position
  Clean up of comments
  Up version to reflect major rewrite
  Add '--no_spec' option to Typer
  ...

OTP-9113

11 files changed, 978 insertions, 1073 deletions

diff --git a/lib/typer/RELEASE_NOTES b/lib/typer/RELEASE_NOTES
new file mode 100644
index 0000000000..d91a815ee9
--- /dev/null
+++ b/lib/typer/RELEASE_NOTES
@@ -0,0 +1,22 @@
+==============================================================================
+	Major features, additions and changes between Typer versions
+		(in reversed chronological order)
+==============================================================================
+
+Version 0.9 (in Erlang/OTP R14B02)
+----------------------------------
+ - Major rewrite; all code has been cleaned up and placed in one file.
+   The only reason why this is not version 1.0 yet is that there is no proper
+   documentation for typer which can be displayed in the www.erlang.org site.
+ - Added ability to receive the set of exported types and report unknown ones.
+ - Better handling of overloaded contracts; especially erroneous ones on which
+   typer does not crash anymore.
+ - Fixed problem that caused typer to hang when given a file whose module name
+   did not correspond to the file name. 
+ - Added two undocumented options that may come very handy when trying to
+   understand why typer reports some particular set of types for the functions
+   in a module. These options are mainly for typer developers at this point,
+   but may become documented in some future version.
+
+Older versions
+--------------
diff --git a/lib/typer/src/Makefile b/lib/typer/src/Makefile
index 9c9ef6156f..3d7827b5b5 100644
--- a/lib/typer/src/Makefile
+++ b/lib/typer/src/Makefile
@@ -45,15 +45,9 @@ DIALYZER_DIR = $(ERL_TOP)/lib/dialyzer
 # ----------------------------------------------------
 # Target Specs
 # ----------------------------------------------------
-MODULES =  \
-	typer \
-	typer_annotator \
-	typer_info \
-	typer_map \
-	typer_options \
-	typer_preprocess
-
-HRL_FILES= typer.hrl
+MODULES = typer
+
+HRL_FILES=
 ERL_FILES= $(MODULES:%=%.erl)
 INSTALL_FILES= $(MODULES:%=$(EBIN)/%.$(EMULATOR)) $(APP_TARGET) $(APPUP_TARGET)
 TARGET_FILES= $(INSTALL_FILES)
@@ -87,8 +81,8 @@ clean:
 # Special Build Targets
 # ----------------------------------------------------
 
-$(EBIN)/typer_options.$(EMULATOR): typer_options.erl ../vsn.mk Makefile
-	erlc -W  $(ERL_COMPILE_FLAGS) -DVSN="\"v$(VSN)\"" -o$(EBIN) typer_options.erl
+$(EBIN)/typer.$(EMULATOR): typer.erl ../vsn.mk Makefile
+	erlc -W  $(ERL_COMPILE_FLAGS) -DVSN="\"v$(VSN)\"" -o$(EBIN) typer.erl
 
 $(APP_TARGET): $(APP_SRC) ../vsn.mk
 	sed -e 's;%VSN%;$(VSN);' $< > $@
@@ -97,14 +91,9 @@ $(APPUP_TARGET): $(APPUP_SRC) ../vsn.mk
 	sed -e 's;%VSN%;$(VSN);' $< > $@
 
 # ---------------------------------------------------------------------
-# dependencies -- I wish they were somehow automatically generated
+# dependencies
 # ---------------------------------------------------------------------
 
-$(EBIN)/typer.beam: typer.hrl
-$(EBIN)/typer_annotator.beam: typer.hrl
-$(EBIN)/typer_info.beam: typer.hrl
-$(EBIN)/typer_options.beam: typer.hrl
-$(EBIN)/typer_preprocess.beam: typer.hrl
 
 # ----------------------------------------------------
 # Release Target
diff --git a/lib/typer/src/typer.app.src b/lib/typer/src/typer.app.src
index 3eb0cbf816..850829e1dc 100644
--- a/lib/typer/src/typer.app.src
+++ b/lib/typer/src/typer.app.src
@@ -3,12 +3,7 @@
 {application, typer,
  [{description, "TYPe annotator for ERlang programs, version %VSN%"},
   {vsn, "%VSN%"},
-  {modules, [typer,
-	     typer_annotator,
-	     typer_info,
-	     typer_map,
-	     typer_options,
-	     typer_preprocess]},
+  {modules, [typer]},
   {registered, []},
   {applications, [compiler, dialyzer, hipe, kernel, stdlib]},
   {env, []}]}.
diff --git a/lib/typer/src/typer.erl b/lib/typer/src/typer.erl
index e19614f911..fc8caa4f21 100644
--- a/lib/typer/src/typer.erl
+++ b/lib/typer/src/typer.erl
@@ -1,65 +1,107 @@
 %% -*- erlang-indent-level: 2 -*-
 %%-----------------------------------------------------------------------
 %% %CopyrightBegin%
-%% 
-%% Copyright Ericsson AB 2006-2010. All Rights Reserved.
-%% 
+%%
+%% Copyright Ericsson AB 2006-2011. All Rights Reserved.
+%%
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
 %% compliance with the License. You should have received a copy of the
 %% Erlang Public License along with this software. If not, it can be
 %% retrieved online at http://www.erlang.org/.
-%% 
+%%
 %% Software distributed under the License is distributed on an "AS IS"
 %% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 %% the License for the specific language governing rights and limitations
 %% under the License.
-%% 
+%%
 %% %CopyrightEnd%
 %%
 
-%%--------------------------------------------------------------------
+%%-----------------------------------------------------------------------
 %% File        : typer.erl
-%% Author      : Bingwen He <[email protected]>
-%% Description : The main driver of the TypEr application
-%%--------------------------------------------------------------------
+%% Author(s)   : The first version of typer was written by Bingwen He
+%%               with guidance from Kostis Sagonas and Tobias Lindahl.
+%%               Since June 2008 typer is maintained by Kostis Sagonas.
+%% Description : An Erlang/OTP application that shows type information
+%%               for Erlang modules to the user.  Additionally, it can
+%%               annotate the code of files with such type information.
+%%-----------------------------------------------------------------------
 
 -module(typer).
 
-%% Avoid warning for local function error/1 clashing with autoimported BIF.
--compile({no_auto_import,[error/1]}).
 -export([start/0]).
--export([error/1, compile_error/1]).	% for error reporting
 
--include("typer.hrl").
+%%-----------------------------------------------------------------------
+
+-define(SHOW, show).
+-define(SHOW_EXPORTED, show_exported).
+-define(ANNOTATE, annotate).
+-define(ANNOTATE_INC_FILES, annotate_inc_files).
+
+-type mode() :: ?SHOW | ?SHOW_EXPORTED | ?ANNOTATE | ?ANNOTATE_INC_FILES.
+
+%%-----------------------------------------------------------------------
+
+-type files()      :: [file:filename()].
+-type callgraph()  :: dialyzer_callgraph:callgraph().
+-type codeserver() :: dialyzer_codeserver:codeserver().
+-type plt()        :: dialyzer_plt:plt().
+
+-record(analysis,
+	{mode				 :: mode() | 'undefined',
+	 macros     = []		 :: [{atom(), term()}],
+	 includes   = []		 :: files(),
+	 codeserver = dialyzer_codeserver:new():: codeserver(),
+	 callgraph  = dialyzer_callgraph:new() :: callgraph(),
+	 files      = []		 :: files(),   % absolute names
+	 plt        = none		 :: 'none' | file:filename(),
+	 no_spec    = false              :: boolean(),
+	 show_succ  = false              :: boolean(),
+	 %% For choosing between specs or edoc @spec comments
+	 edoc       = false		 :: boolean(),
+	 %% Files in 'fms' are compilable with option 'to_pp'; we keep them
+	 %% as {FileName, ModuleName} in case the ModuleName is different
+	 fms        = []		 :: [{file:filename(), module()}],
+	 ex_func    = map__new()	 :: map(),
+	 record     = map__new()	 :: map(),
+	 func       = map__new()	 :: map(),
+	 inc_func   = map__new()	 :: map(),
+	 trust_plt  = dialyzer_plt:new() :: plt()}).
+-type analysis() :: #analysis{}.
+
+-record(args, {files   = [] :: files(),
+	       files_r = [] :: files(),
+	       trusted = [] :: files()}).
+-type args() :: #args{}.
 
 %%--------------------------------------------------------------------
 
 -spec start() -> no_return().
 
 start() ->
-  {Args, Analysis} = typer_options:process(),
+  {Args, Analysis} = process_cl_args(),
   %% io:format("Args: ~p\n", [Args]),
   %% io:format("Analysis: ~p\n", [Analysis]),
-  TrustedFiles = typer_preprocess:get_all_files(Args, trust),
-  Analysis1 = Analysis#typer_analysis{t_files = TrustedFiles},
-  Analysis2 = extract(Analysis1),
-  All_Files = typer_preprocess:get_all_files(Args, analysis),
+  TrustedFiles = filter_fd(Args#args.trusted, [], fun is_erl_file/1),
+  Analysis2 = extract(Analysis, TrustedFiles),
+  All_Files = get_all_files(Args),
   %% io:format("All_Files: ~p\n", [All_Files]),
-  Analysis3 = Analysis2#typer_analysis{ana_files = All_Files},
-  Analysis4 = typer_info:collect(Analysis3),
-  %% io:format("Final: ~p\n", [Analysis4#typer_analysis.final_files]),
+  Analysis3 = Analysis2#analysis{files = All_Files},
+  Analysis4 = collect_info(Analysis3),
+  %% io:format("Final: ~p\n", [Analysis4#analysis.fms]),
   TypeInfo = get_type_info(Analysis4),
-  typer_annotator:annotate(TypeInfo),
+  show_or_annotate(TypeInfo),
   %% io:format("\nTyper analysis finished\n"),
   erlang:halt(0).
 
 %%--------------------------------------------------------------------
 
--spec extract(#typer_analysis{}) -> #typer_analysis{}.
+-spec extract(analysis(), files()) -> analysis().
 
-extract(#typer_analysis{macros = Macros, includes = Includes,
-			t_files = TFiles, trust_plt = TrustPLT} = Analysis) ->
+extract(#analysis{macros = Macros,
+		  includes = Includes,
+		  trust_plt = TrustPLT} = Analysis, TrustedFiles) ->
   %% io:format("--- Extracting trusted typer_info... "),
   Ds = [{d, Name, Value} || {Name, Value} <- Macros],
   CodeServer = dialyzer_codeserver:new(),
@@ -87,7 +129,7 @@ extract(#typer_analysis{macros = Macros, includes = Includes,
 	  {error, Reason} -> compile_error(Reason)
 	end
     end,
-  CodeServer1 = lists:foldl(Fun, CodeServer, TFiles),
+  CodeServer1 = lists:foldl(Fun, CodeServer, TrustedFiles),
   %% Process remote types
   NewCodeServer =
     try
@@ -112,30 +154,30 @@ extract(#typer_analysis{macros = Macros, includes = Includes,
 	dialyzer_plt:insert_contract_list(TmpPlt, SpecList)
     end,
   NewTrustPLT = lists:foldl(FoldFun, TrustPLT, Modules),
-  Analysis#typer_analysis{trust_plt = NewTrustPLT}.
+  Analysis#analysis{trust_plt = NewTrustPLT}.
 
 %%--------------------------------------------------------------------
 
--spec get_type_info(#typer_analysis{}) -> #typer_analysis{}.
+-spec get_type_info(analysis()) -> analysis().
 
-get_type_info(#typer_analysis{callgraph = CallGraph,
-			      trust_plt = TrustPLT,
-			      code_server = CodeServer} = Analysis) ->
+get_type_info(#analysis{callgraph = CallGraph,
+			trust_plt = TrustPLT,
+			codeserver = CodeServer} = Analysis) ->
   StrippedCallGraph = remove_external(CallGraph, TrustPLT),
   %% io:format("--- Analyzing callgraph... "),
   try 
     NewPlt = dialyzer_succ_typings:analyze_callgraph(StrippedCallGraph, 
 						     TrustPLT, CodeServer),
-    Analysis#typer_analysis{callgraph = StrippedCallGraph, trust_plt = NewPlt}
+    Analysis#analysis{callgraph = StrippedCallGraph, trust_plt = NewPlt}
   catch
     error:What ->
-      error(io_lib:format("Analysis failed with message: ~p", 
-			  [{What, erlang:get_stacktrace()}]));
+      fatal_error(io_lib:format("Analysis failed with message: ~p", 
+				[{What, erlang:get_stacktrace()}]));
     throw:{dialyzer_succ_typing_error, Msg} ->
-      error(io_lib:format("Analysis failed with message: ~s", [Msg]))
+      fatal_error(io_lib:format("Analysis failed with message: ~s", [Msg]))
   end.
 
--spec remove_external(dialyzer_callgraph:callgraph(), dialyzer_plt:plt()) -> dialyzer_callgraph:callgraph().
+-spec remove_external(callgraph(), plt()) -> callgraph().
 
 remove_external(CallGraph, PLT) ->
   {StrippedCG0, Ext} = dialyzer_callgraph:remove_external(CallGraph),
@@ -143,11 +185,16 @@ remove_external(CallGraph, PLT) ->
   case get_external(Ext, PLT) of
     [] -> ok;
     Externals ->
-      msg(io_lib:format(" Unknown functions: ~p\n", [lists:usort(Externals)]))
+      msg(io_lib:format(" Unknown functions: ~p\n", [lists:usort(Externals)])),
+      ExtTypes = rcv_ext_types(),
+      case ExtTypes of
+        [] -> ok;
+        _ -> msg(io_lib:format(" Unknown types: ~p\n", [ExtTypes]))
+      end
   end,
   StrippedCG.
 
--spec get_external([{mfa(), mfa()}], dialyzer_plt:plt()) -> [mfa()].
+-spec get_external([{mfa(), mfa()}], plt()) -> [mfa()].
 
 get_external(Exts, Plt) ->
   Fun = fun ({_From, To = {M, F, A}}, Acc) ->
@@ -163,31 +210,782 @@ get_external(Exts, Plt) ->
   lists:foldl(Fun, [], Exts).
 
 %%--------------------------------------------------------------------
+%% Showing type information or annotating files with such information.
+%%--------------------------------------------------------------------
+
+-define(TYPER_ANN_DIR, "typer_ann").
+
+-type line()      :: non_neg_integer().
+-type fa()        :: {atom(), arity()}.
+-type func_info() :: {line(), atom(), arity()}.
+
+-record(info, {records = map__new() :: map(),
+	       functions = []       :: [func_info()],
+	       types = map__new()   :: map(),
+	       edoc = false	    :: boolean()}).
+-record(inc, {map = map__new() :: map(), filter = [] :: files()}).
+-type inc() :: #inc{}.
+
+-spec show_or_annotate(analysis()) -> 'ok'.
+
+show_or_annotate(#analysis{mode = Mode, fms = Files} = Analysis) ->
+  case Mode of
+    ?SHOW -> show(Analysis);
+    ?SHOW_EXPORTED -> show(Analysis);
+    ?ANNOTATE ->
+      Fun = fun ({File, Module}) ->
+		Info = get_final_info(File, Module, Analysis),
+		write_typed_file(File, Info)
+	    end,
+      lists:foreach(Fun, Files);
+    ?ANNOTATE_INC_FILES ->
+      IncInfo = write_and_collect_inc_info(Analysis),
+      write_inc_files(IncInfo)
+  end.
+
+write_and_collect_inc_info(Analysis) ->
+  Fun = fun ({File, Module}, Inc) ->
+	    Info = get_final_info(File, Module, Analysis),
+	    write_typed_file(File, Info),
+	    IncFuns = get_functions(File, Analysis),
+	    collect_imported_functions(IncFuns, Info#info.types, Inc)
+	end,
+  NewInc = lists:foldl(Fun, #inc{}, Analysis#analysis.fms),
+  clean_inc(NewInc).
+
+write_inc_files(Inc) ->
+  Fun =
+    fun (File) ->
+	Val = map__lookup(File, Inc#inc.map),
+	%% Val is function with its type info
+	%% in form [{{Line,F,A},Type}]
+	Functions = [Key || {Key, _} <- Val],
+	Val1 = [{{F,A},Type} || {{_Line,F,A},Type} <- Val],
+	Info = #info{types = map__from_list(Val1),
+		     records = map__new(),
+		     %% Note we need to sort functions here!
+		     functions = lists:keysort(1, Functions)},
+	%% io:format("Types ~p\n", [Info#info.types]),
+	%% io:format("Functions ~p\n", [Info#info.functions]),
+	%% io:format("Records ~p\n", [Info#info.records]),
+	write_typed_file(File, Info)
+    end,
+  lists:foreach(Fun, dict:fetch_keys(Inc#inc.map)).
+
+show(Analysis) ->
+  Fun = fun ({File, Module}) ->
+	    Info = get_final_info(File, Module, Analysis),
+	    show_type_info(File, Info)
+	end,
+  lists:foreach(Fun, Analysis#analysis.fms).
+
+get_final_info(File, Module, Analysis) ->
+  Records = get_records(File, Analysis),
+  Types = get_types(Module, Analysis, Records),
+  Functions = get_functions(File, Analysis),
+  Edoc = Analysis#analysis.edoc,
+  #info{records = Records, functions = Functions, types = Types, edoc = Edoc}.
+
+collect_imported_functions(Functions, Types, Inc) ->
+  %% Coming from other sourses, including:
+  %% FIXME: How to deal with yecc-generated file????
+  %%     --.yrl (yecc-generated file)???
+  %%     -- yeccpre.hrl (yecc-generated file)???
+  %%     -- other cases
+  Fun = fun ({File, _} = Obj, I) ->
+	    case is_yecc_gen(File, I) of
+	      {true, NewI} -> NewI;
+	      {false, NewI} ->
+		check_imported_functions(Obj, NewI, Types)
+	    end
+	end,
+  lists:foldl(Fun, Inc, Functions).
+
+-spec is_yecc_gen(file:filename(), inc()) -> {boolean(), inc()}.
+
+is_yecc_gen(File, #inc{filter = Fs} = Inc) ->
+  case lists:member(File, Fs) of
+    true -> {true, Inc};
+    false ->
+      case filename:extension(File) of
+	".yrl" ->
+	  Rootname = filename:rootname(File, ".yrl"),
+	  Obj = Rootname ++ ".erl",
+	  case lists:member(Obj, Fs) of
+	    true -> {true, Inc};
+	    false ->
+	      NewInc = Inc#inc{filter = [Obj|Fs]},
+	      {true, NewInc}
+	  end;
+	_ ->
+	  case filename:basename(File) of
+	    "yeccpre.hrl" -> {true, Inc};
+	    _ -> {false, Inc}
+	  end
+      end
+  end.
+
+check_imported_functions({File, {Line, F, A}}, Inc, Types) ->
+  IncMap = Inc#inc.map,
+  FA = {F, A},
+  Type = get_type_info(FA, Types),
+  case map__lookup(File, IncMap) of
+    none -> %% File is not added. Add it
+      Obj = {File,[{FA, {Line, Type}}]},
+      NewMap = map__insert(Obj, IncMap),
+      Inc#inc{map = NewMap};
+    Val -> %% File is already in. Check.
+      case lists:keyfind(FA, 1, Val) of
+	false ->
+	  %% Function is not in; add it
+	  Obj = {File, Val ++ [{FA, {Line, Type}}]},
+	  NewMap = map__insert(Obj, IncMap),
+	  Inc#inc{map = NewMap};
+	Type ->
+	  %% Function is in and with same type
+	  Inc;
+	_ ->
+	  %% Function is in but with diff type
+	  inc_warning(FA, File),
+	  Elem = lists:keydelete(FA, 1, Val),
+	  NewMap = case Elem of
+		     [] -> map__remove(File, IncMap);
+		     _  -> map__insert({File, Elem}, IncMap)
+		   end,
+	  Inc#inc{map = NewMap}
+      end
+  end.
+
+inc_warning({F, A}, File) ->
+  io:format("      ***Warning: Skip function ~p/~p ", [F, A]),
+  io:format("in file ~p because of inconsistent type\n", [File]).
+
+clean_inc(Inc) ->
+  Inc1 = remove_yecc_generated_file(Inc),
+  normalize_obj(Inc1).
+
+remove_yecc_generated_file(#inc{filter = Filter} = Inc) ->
+  Fun = fun (Key, #inc{map = Map} = I) ->
+	    I#inc{map = map__remove(Key, Map)}
+	end,
+  lists:foldl(Fun, Inc, Filter).
+
+normalize_obj(TmpInc) ->
+  Fun = fun (Key, Val, Inc) ->
+	    NewVal = [{{Line,F,A},Type} || {{F,A},{Line,Type}} <- Val],
+	    map__insert({Key, NewVal}, Inc)
+	end,
+  TmpInc#inc{map = map__fold(Fun, map__new(), TmpInc#inc.map)}.
+
+get_records(File, Analysis) ->
+  map__lookup(File, Analysis#analysis.record).
+
+get_types(Module, Analysis, Records) ->
+  TypeInfoPlt = Analysis#analysis.trust_plt,
+  TypeInfo = 
+    case dialyzer_plt:lookup_module(TypeInfoPlt, Module) of
+      none -> [];
+      {value, List} -> List
+    end,
+  CodeServer = Analysis#analysis.codeserver,
+  TypeInfoList =
+    case Analysis#analysis.show_succ of
+      true ->
+	[convert_type_info(I) || I <- TypeInfo];
+      false ->
+	[get_type(I, CodeServer, Records) || I <- TypeInfo]
+    end,
+  map__from_list(TypeInfoList).
+
+convert_type_info({{_M, F, A}, Range, Arg}) ->
+  {{F, A}, {Range, Arg}}.
+
+get_type({{M, F, A} = MFA, Range, Arg}, CodeServer, Records) ->
+  case dialyzer_codeserver:lookup_mfa_contract(MFA, CodeServer) of
+    error ->
+      {{F, A}, {Range, Arg}};
+    {ok, {_FileLine, Contract}} ->
+      Sig = erl_types:t_fun(Arg, Range),
+      case dialyzer_contracts:check_contract(Contract, Sig) of
+	ok -> {{F, A}, {contract, Contract}};
+	{error, {extra_range, _, _}} ->
+	  {{F, A}, {contract, Contract}};
+	{error, {overlapping_contract, []}} ->
+	  {{F, A}, {contract, Contract}};
+	{error, invalid_contract} ->
+	  CString = dialyzer_contracts:contract_to_string(Contract),
+	  SigString = dialyzer_utils:format_sig(Sig, Records),
+	  Msg = io_lib:format("Error in contract of function ~w:~w/~w\n" 
+			      "\t The contract is: " ++ CString ++ "\n" ++
+			      "\t but the inferred signature is: ~s",
+			      [M, F, A, SigString]),
+	  fatal_error(Msg);
+	{error, ErrorStr} when is_list(ErrorStr) -> % ErrorStr is a string()
+	  Msg = io_lib:format("Error in contract of function ~w:~w/~w: ~s",
+			      [M, F, A, ErrorStr]),
+	  fatal_error(Msg)
+      end
+  end.
+
+get_functions(File, Analysis) ->
+  case Analysis#analysis.mode of
+    ?SHOW ->
+      Funcs = map__lookup(File, Analysis#analysis.func),
+      Inc_Funcs = map__lookup(File, Analysis#analysis.inc_func),
+      remove_module_info(Funcs) ++ normalize_incFuncs(Inc_Funcs);
+    ?SHOW_EXPORTED ->
+      Ex_Funcs = map__lookup(File, Analysis#analysis.ex_func),
+      remove_module_info(Ex_Funcs);
+    ?ANNOTATE ->
+      Funcs = map__lookup(File, Analysis#analysis.func),
+      remove_module_info(Funcs);
+    ?ANNOTATE_INC_FILES ->
+      map__lookup(File, Analysis#analysis.inc_func)
+  end.
+
+normalize_incFuncs(Functions) ->
+  [FunInfo || {_FileName, FunInfo} <- Functions].
+
+-spec remove_module_info([func_info()]) -> [func_info()].
+
+remove_module_info(FunInfoList) ->
+  F = fun ({_,module_info,0}) -> false;
+	  ({_,module_info,1}) -> false;
+	  ({Line,F,A}) when is_integer(Line), is_atom(F), is_integer(A) -> true
+      end,
+  lists:filter(F, FunInfoList).
+
+write_typed_file(File, Info) ->
+  io:format("      Processing file: ~p\n", [File]),
+  Dir = filename:dirname(File),
+  RootName = filename:basename(filename:rootname(File)),
+  Ext = filename:extension(File),
+  TyperAnnDir = filename:join(Dir, ?TYPER_ANN_DIR),
+  TmpNewFilename = lists:concat([RootName, ".ann", Ext]),
+  NewFileName = filename:join(TyperAnnDir, TmpNewFilename),
+  case file:make_dir(TyperAnnDir) of
+    {error, Reason} ->
+      case Reason of
+	eexist -> %% TypEr dir exists; remove old typer files
+	  ok = file:delete(NewFileName),
+	  write_typed_file(File, Info, NewFileName);
+	enospc ->
+	  Msg = io_lib:format("Not enough space in ~p\n", [Dir]),
+	  fatal_error(Msg);
+	eacces ->
+	  Msg = io:format("No write permission in ~p\n", [Dir]),
+	  fatal_error(Msg);
+	_ ->
+	  Msg = io_lib:format("Unhandled error ~s when writing ~p\n",
+			      [Reason, Dir]),
+	  fatal_error(Msg)
+      end;
+    ok -> %% Typer dir does NOT exist
+      write_typed_file(File, Info, NewFileName)
+  end.
+
+write_typed_file(File, Info, NewFileName) ->
+  {ok, Binary} = file:read_file(File),
+  Chars = binary_to_list(Binary),
+  write_typed_file(Chars, NewFileName, Info, 1, []),
+  io:format("             Saved as: ~p\n", [NewFileName]).
+
+write_typed_file(Chars, File, #info{functions = []}, _LNo, _Acc) ->
+  ok = file:write_file(File, list_to_binary(Chars), [append]);
+write_typed_file([Ch|Chs] = Chars, File, Info, LineNo, Acc) ->
+  [{Line,F,A}|RestFuncs] = Info#info.functions,
+  case Line of
+    1 -> %% This will happen only for inc files
+      ok = raw_write(F, A, Info, File, []),
+      NewInfo = Info#info{functions = RestFuncs},
+      NewAcc = [],
+      write_typed_file(Chars, File, NewInfo, Line, NewAcc);
+    _ ->
+      case Ch of
+	10 ->
+	  NewLineNo = LineNo + 1,
+	  {NewInfo, NewAcc} =
+	    case NewLineNo of
+	      Line ->
+		ok = raw_write(F, A, Info, File, [Ch|Acc]),
+		{Info#info{functions = RestFuncs}, []};
+	      _ ->
+		{Info, [Ch|Acc]}
+	    end,
+	  write_typed_file(Chs, File, NewInfo, NewLineNo, NewAcc);
+	_ ->
+	  write_typed_file(Chs, File, Info, LineNo, [Ch|Acc])
+      end
+  end.
+
+raw_write(F, A, Info, File, Content) ->
+  TypeInfo = get_type_string(F, A, Info, file),
+  ContentList = lists:reverse(Content) ++ TypeInfo ++ "\n",
+  ContentBin = list_to_binary(ContentList),
+  file:write_file(File, ContentBin, [append]).
+
+get_type_string(F, A, Info, Mode) ->
+  Type = get_type_info({F,A}, Info#info.types),
+  TypeStr =
+    case Type of
+      {contract, C} -> 
+        dialyzer_contracts:contract_to_string(C);
+      {RetType, ArgType} ->
+	Sig = erl_types:t_fun(ArgType, RetType),
+        dialyzer_utils:format_sig(Sig, Info#info.records)
+    end,
+  case Info#info.edoc of
+    false ->
+      case {Mode, Type} of
+	{file, {contract, _}} -> "";
+	_ ->
+	  Prefix = lists:concat(["-spec ", F]),
+	  lists:concat([Prefix, TypeStr, "."])
+      end;
+    true ->
+      Prefix = lists:concat(["%% @spec ", F]),
+      lists:concat([Prefix, TypeStr, "."])
+  end.
+ 
+show_type_info(File, Info) ->
+  io:format("\n%% File: ~p\n%% ", [File]),
+  OutputString = lists:concat(["~.", length(File)+8, "c~n"]),
+  io:fwrite(OutputString, [$-]),
+  Fun = fun ({_LineNo, F, A}) ->
+	    TypeInfo = get_type_string(F, A, Info, show),
+	    io:format("~s\n", [TypeInfo])
+	end,
+  lists:foreach(Fun, Info#info.functions).
+
+get_type_info(Func, Types) ->
+  case map__lookup(Func, Types) of
+    none ->
+      %% Note: Typeinfo of any function should exist in
+      %% the result offered by dialyzer, otherwise there 
+      %% *must* be something wrong with the analysis
+      Msg = io_lib:format("No type info for function: ~p\n", [Func]),
+      fatal_error(Msg);
+    {contract, _Fun} = C -> C;
+    {_RetType, _ArgType} = RA -> RA 
+  end.
+
+%%--------------------------------------------------------------------
+%% Processing of command-line options and arguments.
+%%--------------------------------------------------------------------
+
+-spec process_cl_args() -> {args(), analysis()}.
+
+process_cl_args() ->
+  ArgList = init:get_plain_arguments(),
+  %% io:format("Args is ~p\n", [ArgList]),
+  {Args, Analysis} = analyze_args(ArgList, #args{}, #analysis{}),
+  %% if the mode has not been set, set it to the default mode (show)
+  {Args, case Analysis#analysis.mode of
+	   undefined -> Analysis#analysis{mode = ?SHOW};
+	   Mode when is_atom(Mode) -> Analysis
+	 end}.
+
+analyze_args([], Args, Analysis) ->
+  {Args, Analysis};
+analyze_args(ArgList, Args, Analysis) ->
+  {Result, Rest} = cl(ArgList),
+  {NewArgs, NewAnalysis} = analyze_result(Result, Args, Analysis),
+  analyze_args(Rest, NewArgs, NewAnalysis).
+
+cl(["-h"|_])     -> help_message();
+cl(["--help"|_]) -> help_message();
+cl(["-v"|_])        -> version_message();
+cl(["--version"|_]) -> version_message();
+cl(["--edoc"|Opts]) -> {edoc, Opts};
+cl(["--show"|Opts]) -> {{mode, ?SHOW}, Opts};
+cl(["--show_exported"|Opts]) -> {{mode, ?SHOW_EXPORTED}, Opts};
+cl(["--show-exported"|Opts]) -> {{mode, ?SHOW_EXPORTED}, Opts};
+cl(["--show_success_typings"|Opts]) -> {show_succ, Opts};
+cl(["--show-success-typings"|Opts]) -> {show_succ, Opts};
+cl(["--annotate"|Opts]) -> {{mode, ?ANNOTATE}, Opts};
+cl(["--annotate-inc-files"|Opts]) -> {{mode, ?ANNOTATE_INC_FILES}, Opts};
+cl(["--no_spec"|Opts]) -> {no_spec, Opts};
+cl(["--plt",Plt|Opts]) -> {{plt, Plt}, Opts};
+cl(["-D"++Def|Opts]) ->
+  case Def of
+    "" -> fatal_error("no variable name specified after -D");
+    _ ->
+      DefPair = process_def_list(re:split(Def, "=", [{return, list}])),
+      {{def, DefPair}, Opts}
+  end;
+cl(["-I",Dir|Opts]) -> {{inc, Dir}, Opts};
+cl(["-I"++Dir|Opts]) ->
+  case Dir of
+    "" -> fatal_error("no include directory specified after -I");
+    _ -> {{inc, Dir}, Opts}
+  end;
+cl(["-T"|Opts]) ->
+  {Files, RestOpts} = dialyzer_cl_parse:collect_args(Opts),
+  case Files of
+    [] -> fatal_error("no file or directory specified after -T");
+    [_|_] -> {{trusted, Files}, RestOpts}
+  end;
+cl(["-r"|Opts]) ->
+  {Files, RestOpts} = dialyzer_cl_parse:collect_args(Opts),
+  {{files_r, Files}, RestOpts};
+cl(["-"++H|_]) -> fatal_error("unknown option -"++H);
+cl(Opts) -> 
+  {Files, RestOpts} = dialyzer_cl_parse:collect_args(Opts),
+  {{files, Files}, RestOpts}.
+
+process_def_list(L) ->
+  case L of
+    [Name, Value] ->
+      {ok, Tokens, _} = erl_scan:string(Value ++ "."),
+      {ok, ErlValue} = erl_parse:parse_term(Tokens),
+      {list_to_atom(Name), ErlValue};
+    [Name] ->
+      {list_to_atom(Name), true}
+  end.
+
+%% Get information about files that the user trusts and wants to analyze
+analyze_result({files, Val}, Args, Analysis) ->
+  NewVal = Args#args.files ++ Val,
+  {Args#args{files = NewVal}, Analysis};
+analyze_result({files_r, Val}, Args, Analysis) ->
+  NewVal = Args#args.files_r ++ Val,
+  {Args#args{files_r = NewVal}, Analysis};
+analyze_result({trusted, Val}, Args, Analysis) ->
+  NewVal = Args#args.trusted ++ Val,
+  {Args#args{trusted = NewVal}, Analysis};
+analyze_result(edoc, Args, Analysis) ->
+  {Args, Analysis#analysis{edoc = true}};
+%% Get useful information for actual analysis
+analyze_result({mode, Mode}, Args, Analysis) ->
+  case Analysis#analysis.mode of
+    undefined -> {Args, Analysis#analysis{mode = Mode}};
+    OldMode -> mode_error(OldMode, Mode)
+  end;
+analyze_result({def, Val}, Args, Analysis) ->
+  NewVal = Analysis#analysis.macros ++ [Val],
+  {Args, Analysis#analysis{macros = NewVal}};
+analyze_result({inc, Val}, Args, Analysis) ->
+  NewVal = Analysis#analysis.includes ++ [Val],
+  {Args, Analysis#analysis{includes = NewVal}};
+analyze_result({plt, Plt}, Args, Analysis) ->
+  {Args, Analysis#analysis{plt = Plt}};
+analyze_result(show_succ, Args, Analysis) ->
+  {Args, Analysis#analysis{show_succ = true}};
+analyze_result(no_spec, Args, Analysis) ->
+  {Args, Analysis#analysis{no_spec = true}}.
+
+%%--------------------------------------------------------------------
+%% File processing.
+%%--------------------------------------------------------------------
+
+-spec get_all_files(args()) -> [file:filename(),...].
+
+get_all_files(#args{files = Fs, files_r = Ds}) ->
+  case filter_fd(Fs, Ds, fun test_erl_file_exclude_ann/1) of
+    [] -> fatal_error("no file(s) to analyze");
+    AllFiles -> AllFiles
+  end.
 
--spec error(string()) -> no_return().
+-spec test_erl_file_exclude_ann(file:filename()) -> boolean().
 
-error(Slogan) ->
+test_erl_file_exclude_ann(File) ->
+  case is_erl_file(File) of
+    true -> %% Exclude files ending with ".ann.erl"
+      case re:run(File, "[\.]ann[\.]erl$") of
+	{match, _} -> false;
+	nomatch -> true
+      end;
+    false -> false
+  end.
+
+-spec is_erl_file(file:filename()) -> boolean().
+
+is_erl_file(File) ->
+  filename:extension(File) =:= ".erl".
+
+-type test_file_fun() :: fun((file:filename()) -> boolean()).
+
+-spec filter_fd(files(), files(), test_file_fun()) -> files().
+
+filter_fd(File_Dir, Dir_R, Fun) ->
+  All_File_1 = process_file_and_dir(File_Dir, Fun),
+  All_File_2 = process_dir_rec(Dir_R, Fun),
+  remove_dup(All_File_1 ++ All_File_2).
+
+-spec process_file_and_dir(files(), test_file_fun()) -> files().
+
+process_file_and_dir(File_Dir, TestFun) ->
+  Fun =
+    fun (Elem, Acc) ->
+	case filelib:is_regular(Elem) of
+	  true  -> process_file(Elem, TestFun, Acc);
+	  false -> check_dir(Elem, false, Acc, TestFun)
+	end
+    end,
+  lists:foldl(Fun, [], File_Dir).
+
+-spec process_dir_rec(files(), test_file_fun()) -> files().
+
+process_dir_rec(Dirs, TestFun) ->
+  Fun = fun (Dir, Acc) -> check_dir(Dir, true, Acc, TestFun) end,
+  lists:foldl(Fun, [], Dirs).
+
+-spec check_dir(file:filename(), boolean(), files(), test_file_fun()) -> files().
+
+check_dir(Dir, Recursive, Acc, Fun) ->
+  case file:list_dir(Dir) of
+    {ok, Files} ->
+      {TmpDirs, TmpFiles} = split_dirs_and_files(Files, Dir),
+      case Recursive of
+	false ->
+	  FinalFiles = process_file_and_dir(TmpFiles, Fun),
+	  Acc ++ FinalFiles;
+	true ->
+	  TmpAcc1 = process_file_and_dir(TmpFiles, Fun),
+	  TmpAcc2 = process_dir_rec(TmpDirs, Fun),
+	  Acc ++ TmpAcc1 ++ TmpAcc2
+      end;
+    {error, eacces} ->
+      fatal_error("no access permission to dir \""++Dir++"\"");
+    {error, enoent} ->
+      fatal_error("cannot access "++Dir++": No such file or directory");
+    {error, _Reason} ->
+      fatal_error("error involving a use of file:list_dir/1")
+  end.
+
+%% Same order as the input list
+-spec process_file(file:filename(), test_file_fun(), files()) -> files().
+
+process_file(File, TestFun, Acc) ->
+  case TestFun(File) of
+    true  -> Acc ++ [File];
+    false -> Acc
+  end.
+
+%% Same order as the input list
+-spec split_dirs_and_files(files(), file:filename()) -> {files(), files()}.
+
+split_dirs_and_files(Elems, Dir) ->
+  Test_Fun =
+    fun (Elem, {DirAcc, FileAcc}) ->
+	File = filename:join(Dir, Elem),
+	case filelib:is_regular(File) of
+	  false -> {[File|DirAcc], FileAcc}; 
+	  true  -> {DirAcc, [File|FileAcc]}
+	end
+    end,
+  {Dirs, Files} = lists:foldl(Test_Fun, {[], []}, Elems),
+  {lists:reverse(Dirs), lists:reverse(Files)}.  
+
+%% Removes duplicate filenames but keeps the order of the input list
+-spec remove_dup(files()) -> files().
+
+remove_dup(Files) ->
+  Test_Dup = fun (File, Acc) ->
+		 case lists:member(File, Acc) of
+		   true  -> Acc;
+		   false -> [File|Acc]
+		 end
+	     end,
+  Reversed_Elems = lists:foldl(Test_Dup, [], Files),
+  lists:reverse(Reversed_Elems).
+
+%%--------------------------------------------------------------------
+%% Collect information.
+%%--------------------------------------------------------------------
+
+-type inc_file_info() :: {file:filename(), func_info()}.
+
+-record(tmpAcc, {file		  :: file:filename(),
+		 module		  :: atom(),
+		 funcAcc = []	  :: [func_info()],
+		 incFuncAcc = []  :: [inc_file_info()],
+		 dialyzerObj = [] :: [{mfa(), {_, _}}]}).
+
+-spec collect_info(analysis()) -> analysis().
+
+collect_info(Analysis) ->
+  NewPlt =
+    try get_dialyzer_plt(Analysis) of
+	DialyzerPlt ->
+	dialyzer_plt:merge_plts([Analysis#analysis.trust_plt, DialyzerPlt])
+    catch
+      throw:{dialyzer_error,_Reason} ->
+	fatal_error("Dialyzer's PLT is missing or is not up-to-date; please (re)create it")
+    end,
+  NewAnalysis = lists:foldl(fun collect_one_file_info/2, 
+			    Analysis#analysis{trust_plt = NewPlt}, 
+			    Analysis#analysis.files),
+  %% Process Remote Types
+  TmpCServer = NewAnalysis#analysis.codeserver,
+  NewCServer =
+    try
+      NewRecords = dialyzer_codeserver:get_temp_records(TmpCServer),
+      NewExpTypes = dialyzer_codeserver:get_temp_exported_types(TmpCServer),
+      OldRecords = dialyzer_plt:get_types(NewPlt),
+      OldExpTypes = dialyzer_plt:get_exported_types(NewPlt),
+      MergedRecords = dialyzer_utils:merge_records(NewRecords, OldRecords),
+      MergedExpTypes = sets:union(NewExpTypes, OldExpTypes),
+      %% io:format("Merged Records ~p",[MergedRecords]),
+      TmpCServer1 = dialyzer_codeserver:set_temp_records(MergedRecords, TmpCServer),
+      TmpCServer2 =
+        dialyzer_codeserver:insert_temp_exported_types(MergedExpTypes,
+                                                       TmpCServer1),
+      TmpCServer3 = dialyzer_utils:process_record_remote_types(TmpCServer2),
+      dialyzer_contracts:process_contract_remote_types(TmpCServer3)
+    catch
+      throw:{error, ErrorMsg} ->
+	fatal_error(ErrorMsg)
+    end,
+  NewAnalysis#analysis{codeserver = NewCServer}.
+
+collect_one_file_info(File, Analysis) ->
+  Ds = [{d,Name,Val} || {Name,Val} <- Analysis#analysis.macros],
+  %% Current directory should also be included in "Includes".
+  Includes = [filename:dirname(File)|Analysis#analysis.includes],
+  Is = [{i,Dir} || Dir <- Includes],
+  Options = dialyzer_utils:src_compiler_opts() ++ Is ++ Ds,
+  case dialyzer_utils:get_abstract_code_from_src(File, Options) of
+    {error, Reason} ->
+      %% io:format("File=~p\n,Options=~p\n,Error=~p\n", [File,Options,Reason]),
+      compile_error(Reason);
+    {ok, AbstractCode} ->
+      case dialyzer_utils:get_core_from_abstract_code(AbstractCode, Options) of
+	error -> compile_error(["Could not get core erlang for "++File]);
+	{ok, Core} ->
+	  case dialyzer_utils:get_record_and_type_info(AbstractCode) of
+	    {error, Reason} -> compile_error([Reason]);
+	    {ok, Records} ->
+	      Mod = cerl:concrete(cerl:module_name(Core)),
+	      case dialyzer_utils:get_spec_info(Mod, AbstractCode, Records) of
+		{error, Reason} -> compile_error([Reason]);
+		{ok, SpecInfo} ->
+                  ExpTypes = get_exported_types_from_core(Core),
+		  analyze_core_tree(Core, Records, SpecInfo, ExpTypes,
+                                    Analysis, File)
+	      end
+	  end
+      end
+  end.
+
+analyze_core_tree(Core, Records, SpecInfo, ExpTypes, Analysis, File) ->
+  Module = cerl:concrete(cerl:module_name(Core)),
+  TmpTree = cerl:from_records(Core),
+  CS1 = Analysis#analysis.codeserver,
+  NextLabel = dialyzer_codeserver:get_next_core_label(CS1),
+  {Tree, NewLabel} = cerl_trees:label(TmpTree, NextLabel),
+  CS2 = dialyzer_codeserver:insert(Module, Tree, CS1),
+  CS3 = dialyzer_codeserver:set_next_core_label(NewLabel, CS2),
+  CS4 = dialyzer_codeserver:store_temp_records(Module, Records, CS3),
+  CS5 =
+    case Analysis#analysis.no_spec of
+      true -> CS4;
+      false -> dialyzer_codeserver:store_temp_contracts(Module, SpecInfo, CS4)
+    end,
+  OldExpTypes = dialyzer_codeserver:get_temp_exported_types(CS5),
+  MergedExpTypes = sets:union(ExpTypes, OldExpTypes),
+  CS6 = dialyzer_codeserver:insert_temp_exported_types(MergedExpTypes, CS5),
+  Ex_Funcs = [{0,F,A} || {_,_,{F,A}} <- cerl:module_exports(Tree)],
+  TmpCG = Analysis#analysis.callgraph,
+  CG = dialyzer_callgraph:scan_core_tree(Tree, TmpCG),
+  Fun = fun analyze_one_function/2,
+  All_Defs = cerl:module_defs(Tree),
+  Acc = lists:foldl(Fun, #tmpAcc{file = File, module = Module}, All_Defs),
+  Exported_FuncMap = map__insert({File, Ex_Funcs}, Analysis#analysis.ex_func),
+  %% we must sort all functions in the file which
+  %% originate from this file by *numerical order* of lineNo
+  Sorted_Functions = lists:keysort(1, Acc#tmpAcc.funcAcc),
+  FuncMap = map__insert({File, Sorted_Functions}, Analysis#analysis.func),
+  %% we do not need to sort functions which are imported from included files
+  IncFuncMap = map__insert({File, Acc#tmpAcc.incFuncAcc},
+			   Analysis#analysis.inc_func),
+  FMs = Analysis#analysis.fms ++ [{File, Module}],
+  RecordMap = map__insert({File, Records}, Analysis#analysis.record),
+  Analysis#analysis{fms = FMs,
+		    callgraph = CG,
+		    codeserver = CS6,
+		    ex_func = Exported_FuncMap,
+		    inc_func = IncFuncMap,
+		    record = RecordMap,
+		    func = FuncMap}.
+
+analyze_one_function({Var, FunBody} = Function, Acc) ->
+  F = cerl:fname_id(Var),
+  A = cerl:fname_arity(Var),
+  TmpDialyzerObj = {{Acc#tmpAcc.module, F, A}, Function},
+  NewDialyzerObj = Acc#tmpAcc.dialyzerObj ++ [TmpDialyzerObj],  
+  [_, LineNo, {file, FileName}] = cerl:get_ann(FunBody),
+  BaseName = filename:basename(FileName),
+  FuncInfo = {LineNo, F, A},
+  OriginalName = Acc#tmpAcc.file,
+  {FuncAcc, IncFuncAcc} =
+    case (FileName =:= OriginalName) orelse (BaseName =:= OriginalName) of
+      true -> %% Coming from original file
+	%% io:format("Added function ~p\n", [{LineNo, F, A}]),
+	{Acc#tmpAcc.funcAcc ++ [FuncInfo], Acc#tmpAcc.incFuncAcc};
+      false ->
+	%% Coming from other sourses, including:
+	%%     -- .yrl (yecc-generated file)
+	%%     -- yeccpre.hrl (yecc-generated file)
+	%%     -- other cases
+	{Acc#tmpAcc.funcAcc, Acc#tmpAcc.incFuncAcc ++ [{FileName, FuncInfo}]}
+    end,
+  Acc#tmpAcc{funcAcc = FuncAcc,
+	     incFuncAcc = IncFuncAcc,
+	     dialyzerObj = NewDialyzerObj}.
+
+-spec get_dialyzer_plt(analysis()) -> plt().
+
+get_dialyzer_plt(#analysis{plt = PltFile0}) ->
+  PltFile =
+    case PltFile0 =:= none of
+      true -> dialyzer_plt:get_default_plt();
+      false -> PltFile0
+    end,
+  dialyzer_plt:from_file(PltFile).
+
+%% Exported Types
+
+get_exported_types_from_core(Core) ->
+  Attrs = cerl:module_attrs(Core),
+  ExpTypes1 = [cerl:concrete(L2) || {L1, L2} <- Attrs,
+                                    cerl:is_literal(L1),
+                                    cerl:is_literal(L2),
+                                    cerl:concrete(L1) =:= 'export_type'],
+  ExpTypes2 = lists:flatten(ExpTypes1),
+  M = cerl:atom_val(cerl:module_name(Core)),
+  sets:from_list([{M, F, A} || {F, A} <- ExpTypes2]).
+
+%%--------------------------------------------------------------------
+%% Utilities for error reporting.
+%%--------------------------------------------------------------------
+
+-spec fatal_error(string()) -> no_return().
+
+fatal_error(Slogan) ->
   msg(io_lib:format("typer: ~s\n", [Slogan])),
   erlang:halt(1).
 
-%%--------------------------------------------------------------------
+-spec mode_error(mode(), mode()) -> no_return().
+
+mode_error(OldMode, NewMode) ->
+  Msg = io_lib:format("Mode was previously set to '~s'; "
+		      "can not set it to '~s' now",
+		      [OldMode, NewMode]),
+  fatal_error(Msg).
 
 -spec compile_error([string()]) -> no_return().
 
 compile_error(Reason) ->
   JoinedString = lists:flatten([X ++ "\n" || X <- Reason]),
   Msg = "Analysis failed with error report:\n" ++ JoinedString,
-  error(Msg).
-
-%%--------------------------------------------------------------------
-%% Outputs a message on 'stderr', if possible.
-%%--------------------------------------------------------------------
+  fatal_error(Msg).
 
 -spec msg(string()) -> 'ok'.
 
 msg(Msg) ->
   case os:type() of
-    {unix, _} ->
+    {unix, _} -> % Output a message on 'stderr', if possible
       P = open_port({fd, 0, 2}, [out]),
       port_command(P, Msg),
       true = port_close(P),
@@ -197,3 +995,106 @@ msg(Msg) ->
   end.
 
 %%--------------------------------------------------------------------
+%% Version and help messages.
+%%--------------------------------------------------------------------
+
+-spec version_message() -> no_return().
+
+version_message() ->
+  io:format("TypEr version "++?VSN++"\n"),
+  erlang:halt(0).
+
+-spec help_message() -> no_return().
+
+help_message() ->
+  S = <<" Usage: typer [--help] [--version] [--plt PLT] [--edoc]
+              [--show | --show-exported | --annotate | --annotate-inc-files]
+              [-Ddefine]* [-I include_dir]* [-T application]* [-r] file*
+
+ Options:
+   -r dir*
+       search directories recursively for .erl files below them
+   --show
+       Prints type specifications for all functions on stdout.
+       (this is the default behaviour; this option is not really needed)
+   --show-exported (or --show_exported)
+       Same as --show, but prints specifications for exported functions only
+       Specs are displayed sorted alphabetically on the function's name
+   --annotate
+       Annotates the specified files with type specifications
+   --annotate-inc-files
+       Same as --annotate but annotates all -include() files as well as
+       all .erl files (use this option with caution - has not been tested much)
+   --edoc
+       Prints type information as Edoc @spec comments, not as type specs
+   --plt PLT
+       Use the specified dialyzer PLT file rather than the default one
+   -T file*
+       The specified file(s) already contain type specifications and these
+       are to be trusted in order to print specs for the rest of the files
+       (Multiple files or dirs, separated by spaces, can be specified.)
+   -Dname (or -Dname=value)
+       pass the defined name(s) to TypEr
+       (The syntax of defines is the same as that used by \"erlc\".)
+   -I include_dir
+       pass the include_dir to TypEr
+       (The syntax of includes is the same as that used by \"erlc\".)
+   --version (or -v)
+       prints the Typer version and exits
+   --help (or -h)
+       prints this message and exits
+
+ Note:
+   * denotes that multiple occurrences of these options are possible.
+">>,
+  io:put_chars(S),
+  erlang:halt(0).
+
+%%--------------------------------------------------------------------
+%% Handle messages.                         
+%%-------------------------------------------------------------------- 
+
+rcv_ext_types() ->
+  Self = self(),
+  Self ! {Self, done},
+  rcv_ext_types(Self, []).
+
+rcv_ext_types(Self, ExtTypes) ->
+  receive
+    {Self, ext_types, ExtType} ->
+      rcv_ext_types(Self, [ExtType|ExtTypes]);
+    {Self, done} ->
+      lists:usort(ExtTypes)
+  end.
+
+%%--------------------------------------------------------------------
+%% A convenient abstraction of a Key-Value mapping data structure
+%% specialized for the uses in this module
+%%--------------------------------------------------------------------
+
+-type map() :: dict().
+
+-spec map__new() -> map().
+map__new() ->
+  dict:new().
+
+-spec map__insert({term(), term()}, map()) -> map().
+map__insert(Object, Map) ->
+  {Key, Value} = Object,
+  dict:store(Key, Value, Map).
+
+-spec map__lookup(term(), map()) -> term().
+map__lookup(Key, Map) ->
+  try dict:fetch(Key, Map) catch error:_ -> none end.
+
+-spec map__from_list([{fa(), term()}]) -> map().
+map__from_list(List) ->
+  dict:from_list(List).
+
+-spec map__remove(term(), map()) -> map().
+map__remove(Key, Dict) ->
+  dict:erase(Key, Dict).
+
+-spec map__fold(fun((term(), term(), term()) -> map()), map(), map()) -> map().
+map__fold(Fun, Acc0, Dict) -> 
+  dict:fold(Fun, Acc0, Dict).
diff --git a/lib/typer/src/typer.hrl b/lib/typer/src/typer.hrl
deleted file mode 100644
index c331dd82db..0000000000
--- a/lib/typer/src/typer.hrl
+++ /dev/null
@@ -1,64 +0,0 @@
-%% -*- erlang-indent-level: 2 -*-
-%%
-%% %CopyrightBegin%
-%% 
-%% Copyright Ericsson AB 2006-2009. All Rights Reserved.
-%% 
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
-%% 
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
-%% 
-%% %CopyrightEnd%
-%%
-
--define(SHOW, show).
--define(SHOW_EXPORTED, show_exported).
--define(ANNOTATE, annotate).
--define(ANNOTATE_INC_FILES, annotate_inc_files).
-
--type mode() :: ?SHOW | ?SHOW_EXPORTED | ?ANNOTATE | ?ANNOTATE_INC_FILES.
-
--record(typer_analysis,
-	{mode					:: mode(),
-	 macros      = []			:: [{atom(), _}], % {macro_name, value}
-	 includes    = []			:: [string()],
-	 
-	 %% Esp for Dialyzer
-	 %% ----------------------
-	 code_server = dialyzer_codeserver:new():: dialyzer_codeserver:codeserver(),
-	 callgraph   = dialyzer_callgraph:new() :: dialyzer_callgraph:callgraph(),
-	 ana_files   = []			:: [string()],   % absolute filenames
-	 plt         = none			:: 'none' | string(),
-	 
-	 %% Esp for TypEr
-	 %% ----------------------
-	 t_files     = []			:: [string()], 
-	 
-	 %% For choosing between contracts or comments
-	 contracts   = true			:: boolean(),
-	 
-	 %% Any file in 'final_files' is compilable.
-	 %% And we need to keep it as {FileName,ModuleName}
-	 %% in case filename does NOT match with moduleName
-	 final_files = []			:: [{string(), atom()}],  
-	 
-	 ex_func     = typer_map:new()		:: dict(),
-	 record      = typer_map:new()		:: dict(),
-	 
-	 %% Functions: the line number of the function 
-	 %%            should be kept as well
-	 func        = typer_map:new()		:: dict(),
-	 inc_func    = typer_map:new()		:: dict(),
-	 trust_plt   = dialyzer_plt:new()	:: dialyzer_plt:plt()}).
-
--record(args,
-	{analyze = []        :: [string()],
-	 analyzed_dir_r = [] :: [string()],
-	 trust = []          :: [string()]}).
diff --git a/lib/typer/src/typer_annotator.erl b/lib/typer/src/typer_annotator.erl
deleted file mode 100644
index 68a8f03a5c..0000000000
--- a/lib/typer/src/typer_annotator.erl
+++ /dev/null
@@ -1,384 +0,0 @@
-%% -*- erlang-indent-level: 2 -*-
-%%
-%% %CopyrightBegin%
-%%
-%% Copyright Ericsson AB 2008-2010. All Rights Reserved.
-%%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
-%%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
-%%
-%% %CopyrightEnd%
-%%
-%%============================================================================
-%% File    : typer_annotator.erl
-%% Author  : Bingwen He <[email protected]>
-%% Description : 
-%%    If file 'FILENAME' has been analyzed, then the output of
-%%    command "diff -B FILENAME.erl typer_ann/FILENAME.ann.erl"
-%%    should be exactly what TypEr has added, namely type info.
-%%============================================================================
-
--module(typer_annotator).
-
--export([annotate/1]).
-
-%%----------------------------------------------------------------------------
-
--include("typer.hrl").
-
-%%----------------------------------------------------------------------------
-
--define(TYPER_ANN_DIR, "typer_ann").
-
--type func_info() :: {non_neg_integer(), atom(), arity()}.
-
--record(info, {recMap = typer_map:new() :: dict(),
-	       funcs = []               :: [func_info()],
-	       typeMap                  :: dict(),
-	       contracts                :: boolean()}).
--record(inc, {map    = typer_map:new() :: dict(),
-	      filter = []              :: [string()]}).
-
-%%----------------------------------------------------------------------------
-
--spec annotate(#typer_analysis{}) -> 'ok'.
-
-annotate(Analysis) ->
-  case Analysis#typer_analysis.mode of
-    ?SHOW -> show(Analysis);
-    ?SHOW_EXPORTED -> show(Analysis);
-    ?ANNOTATE ->
-      Fun = fun({File, Module}) ->
-		Info = get_final_info(File, Module, Analysis),
-		write_typed_file(File, Info)
-	    end,
-      lists:foreach(Fun, Analysis#typer_analysis.final_files);
-    ?ANNOTATE_INC_FILES ->
-      IncInfo = write_and_collect_inc_info(Analysis),
-      write_inc_files(IncInfo)
-  end.
-
-write_and_collect_inc_info(Analysis) ->
-  Fun = fun({File, Module}, Inc) ->
-	    Info = get_final_info(File, Module, Analysis),
-	    write_typed_file(File, Info),
-	    IncFuns = get_functions(File, Analysis),
-	    collect_imported_funcs(IncFuns, Info#info.typeMap, Inc)
-	end,
-  NewInc = lists:foldl(Fun,#inc{}, Analysis#typer_analysis.final_files),
-  clean_inc(NewInc).
-
-write_inc_files(Inc) ->
-  Fun =
-    fun (File) ->
-	Val = typer_map:lookup(File,Inc#inc.map),
-	%% Val is function with its type info
-	%% in form [{{Line,F,A},Type}]
-	Functions = [Key || {Key,_} <- Val],
-	Val1 = [{{F,A},Type} || {{_Line,F,A},Type} <- Val],
-	Info = #info{typeMap = typer_map:from_list(Val1),
-		     recMap = typer_map:new(),
-		     %% Note we need to sort functions here!
-		     funcs = lists:keysort(1, Functions)},
-	%% io:format("TypeMap ~p\n", [Info#info.typeMap]),
-	%% io:format("Funcs ~p\n", [Info#info.funcs]),
-	%% io:format("RecMap ~p\n", [Info#info.recMap]),
-	write_typed_file(File, Info)
-    end,
-  lists:foreach(Fun, dict:fetch_keys(Inc#inc.map)).
-
-show(Analysis) ->
-  Fun = fun({File, Module}) -> 
-	    Info = get_final_info(File, Module, Analysis),
-	    show_type_info_only(File, Info)
-	end,
-  lists:foreach(Fun, Analysis#typer_analysis.final_files).
-
-get_final_info(File, Module, Analysis) ->
-  RecMap = get_recMap(File, Analysis),
-  TypeMap = get_typeMap(Module, Analysis,RecMap),
-  Functions = get_functions(File, Analysis),
-  Contracts = Analysis#typer_analysis.contracts,
-  #info{recMap=RecMap, funcs=Functions, typeMap=TypeMap, contracts=Contracts}.
-
-collect_imported_funcs(Funcs, TypeMap, TmpInc) ->
-  %% Coming from other sourses, including:
-  %% FIXME: How to deal with yecc-generated file????
-  %%     --.yrl (yecc-generated file)???
-  %%     -- yeccpre.hrl (yecc-generated file)???
-  %%     -- other cases
-  Fun = fun({File,_} = Obj, Inc) ->
-	    case is_yecc_file(File, Inc) of
-	      {yecc_generated, NewInc} -> NewInc;
-	      {not_yecc, NewInc} ->
-		check_imported_funcs(Obj, NewInc, TypeMap)
-	    end
-	end,
-  lists:foldl(Fun, TmpInc, Funcs).
-
--spec is_yecc_file(string(), #inc{}) -> {'not_yecc', #inc{}}
-				      | {'yecc_generated', #inc{}}.
-is_yecc_file(File, Inc) ->
-  case lists:member(File, Inc#inc.filter) of
-    true -> {yecc_generated, Inc};
-    false ->
-      case filename:extension(File) of
-	".yrl" ->
-	  Rootname = filename:rootname(File, ".yrl"),
-	  Obj = Rootname ++ ".erl",
-	  case lists:member(Obj, Inc#inc.filter) of
-	    true -> {yecc_generated, Inc};
-	    false ->
-	      NewFilter = [Obj|Inc#inc.filter],
-	      NewInc = Inc#inc{filter = NewFilter},
-	      {yecc_generated, NewInc}
-	  end;
-	_ ->
-	  case filename:basename(File) of
-	    "yeccpre.hrl" -> {yecc_generated, Inc};
-	    _ -> {not_yecc, Inc}
-	  end
-      end
-  end.
-
-check_imported_funcs({File, {Line, F, A}}, Inc, TypeMap) ->
-  IncMap = Inc#inc.map,
-  FA = {F, A},
-  Type = get_type_info(FA, TypeMap),
-  case typer_map:lookup(File, IncMap) of
-    none -> %% File is not added. Add it
-      Obj = {File,[{FA, {Line, Type}}]},
-      NewMap = typer_map:insert(Obj, IncMap),
-      Inc#inc{map = NewMap};
-    Val -> %% File is already in. Check.
-      case lists:keyfind(FA, 1, Val) of
-	false ->
-	  %% Function is not in; add it
-	  Obj = {File, Val ++ [{FA, {Line, Type}}]},
-	  NewMap = typer_map:insert(Obj, IncMap),
-	  Inc#inc{map = NewMap};
-	Type ->
-	  %% Function is in and with same type
-	  Inc;
-	_ ->
-	  %% Function is in but with diff type
-	  inc_warning(FA, File),
-	  Elem = lists:keydelete(FA, 1, Val),
-	  NewMap = case Elem of
-		     [] ->
-		       typer_map:remove(File, IncMap);
-		     _  ->
-		       typer_map:insert({File, Elem}, IncMap)
-		   end,
-	  Inc#inc{map = NewMap}
-      end
-  end.
-
-inc_warning({F, A}, File) ->
-  io:format("      ***Warning: Skip function ~p/~p ", [F, A]),
-  io:format("in file ~p because of inconsistent type\n", [File]).
-
-clean_inc(Inc) ->
-  Inc1 = remove_yecc_generated_file(Inc),
-  normalize_obj(Inc1).
-
-remove_yecc_generated_file(TmpInc) ->
-  Fun = fun(Key, Inc) ->
-	    NewMap = typer_map:remove(Key, Inc#inc.map),
-	    Inc#inc{map = NewMap}
-	end,
-  lists:foldl(Fun, TmpInc, TmpInc#inc.filter).
-  
-normalize_obj(TmpInc) ->
-  Fun = fun(Key, Val, Inc) ->
-	    NewVal = [{{Line,F,A},Type} || {{F,A},{Line,Type}} <- Val],
-	    typer_map:insert({Key,NewVal}, Inc)
-	end,
-  NewMap = typer_map:fold(Fun, typer_map:new(), TmpInc#inc.map),
-  TmpInc#inc{map = NewMap}.
-
-get_recMap(File, Analysis) ->
-  typer_map:lookup(File, Analysis#typer_analysis.record).
-
-get_typeMap(Module, Analysis, RecMap) ->
-  TypeInfoPlt = Analysis#typer_analysis.trust_plt,
-  TypeInfo = 
-    case dialyzer_plt:lookup_module(TypeInfoPlt, Module) of
-      none -> [];
-      {value, List} -> List
-    end,
-  CodeServer = Analysis#typer_analysis.code_server,
-  TypeInfoList = [get_type(I, CodeServer, RecMap) || I <- TypeInfo],
-  typer_map:from_list(TypeInfoList).
-
-get_type({{M, F, A} = MFA, Range, Arg}, CodeServer, RecMap) ->
-  case dialyzer_codeserver:lookup_mfa_contract(MFA, CodeServer) of
-    error ->
-      {{F, A}, {Range, Arg}};
-    {ok, {_FileLine, Contract}} ->
-      Sig = erl_types:t_fun(Arg, Range),
-      case dialyzer_contracts:check_contract(Contract, Sig) of
-	ok -> {{F, A}, {contract, Contract}};
-	{error, {extra_range, _, _}} ->
-	  {{F, A}, {contract, Contract}};
-	{error, invalid_contract} ->
-	  CString = dialyzer_contracts:contract_to_string(Contract),
-	  SigString = dialyzer_utils:format_sig(Sig, RecMap),
-	  typer:error(
-	    io_lib:format("Error in contract of function ~w:~w/~w\n" 
-			  "\t The contract is: " ++ CString ++ "\n" ++
-			  "\t but the inferred signature is: ~s",
-			  [M, F, A, SigString]));
-	{error, Msg} when is_list(Msg) -> % Msg is a string()
-	  typer:error(
-	    io_lib:format("Error in contract of function ~w:~w/~w: ~s",
-			  [M, F, A, Msg]))
-      end
-  end.
-
-get_functions(File, Analysis) ->
-  case Analysis#typer_analysis.mode of
-    ?SHOW ->
-      Funcs = typer_map:lookup(File, Analysis#typer_analysis.func),
-      Inc_Funcs = typer_map:lookup(File, Analysis#typer_analysis.inc_func),
-      remove_module_info(Funcs) ++ normalize_incFuncs(Inc_Funcs);
-    ?SHOW_EXPORTED ->
-      Ex_Funcs = typer_map:lookup(File, Analysis#typer_analysis.ex_func),
-      remove_module_info(Ex_Funcs);
-    ?ANNOTATE ->
-      Funcs = typer_map:lookup(File, Analysis#typer_analysis.func),
-      remove_module_info(Funcs);
-    ?ANNOTATE_INC_FILES ->
-      typer_map:lookup(File, Analysis#typer_analysis.inc_func)
-  end.
-
-normalize_incFuncs(Funcs) ->
-  [FuncInfo || {_FileName, FuncInfo} <- Funcs].
-
--spec remove_module_info([func_info()]) -> [func_info()].
-
-remove_module_info(FuncInfoList) ->
-  F = fun ({_,module_info,0}) -> false;
-	  ({_,module_info,1}) -> false;
-	  ({Line,F,A}) when is_integer(Line), is_atom(F), is_integer(A) -> true
-      end,
-  lists:filter(F, FuncInfoList).
-
-write_typed_file(File, Info) ->
-  io:format("      Processing file: ~p\n", [File]),
-  Dir = filename:dirname(File),
-  RootName = filename:basename(filename:rootname(File)),
-  Ext = filename:extension(File),
-  TyperAnnDir = filename:join(Dir, ?TYPER_ANN_DIR),
-  TmpNewFilename = lists:concat([RootName,".ann",Ext]),
-  NewFileName = filename:join(TyperAnnDir, TmpNewFilename),
-  case file:make_dir(TyperAnnDir) of
-    {error, Reason} ->
-      case Reason of
-	eexist -> %% TypEr dir exists; remove old typer files
-	  ok = file:delete(NewFileName),
-	  write_typed_file(File, Info, NewFileName);
-	enospc ->
-	  io:format("  Not enough space in ~p\n", [Dir]);
-	eacces ->
-	  io:format("  No write permission in ~p\n", [Dir]);
-	_ ->
-	  io:format("Unknown error when writing ~p\n", [Dir]),
-	  halt()
-      end;
-    ok -> %% Typer dir does NOT exist
-      write_typed_file(File, Info, NewFileName)
-  end.
-
-write_typed_file(File, Info, NewFileName) ->
-  {ok, Binary} = file:read_file(File),
-  Chars = binary_to_list(Binary),
-  write_typed_file(Chars, NewFileName, Info, 1, []),
-  io:format("             Saved as: ~p\n", [NewFileName]).
-
-write_typed_file(Chars, File, #info{funcs = []}, _LNo, _Acc) ->
-  ok = file:write_file(File, list_to_binary(Chars), [append]);
-write_typed_file([Ch|Chs] = Chars, File, Info, LineNo, Acc) ->
-  [{Line,F,A}|RestFuncs] = Info#info.funcs,
-  case Line of
-    1 -> %% This will happen only for inc files
-      ok = raw_write(F, A, Info, File, []),
-      NewInfo = Info#info{funcs = RestFuncs},
-      NewAcc = [],
-      write_typed_file(Chars, File, NewInfo, Line, NewAcc);
-    _ ->
-      case Ch of
-	10 ->
-	  NewLineNo = LineNo + 1,
-	  {NewInfo, NewAcc} =
-	    case NewLineNo of
-	      Line ->
-		ok = raw_write(F, A, Info, File, [Ch|Acc]),
-		{Info#info{funcs = RestFuncs}, []};
-	      _ ->
-		{Info, [Ch|Acc]}
-	    end,
-	  write_typed_file(Chs, File, NewInfo, NewLineNo, NewAcc);
-	_ ->
-	  write_typed_file(Chs, File, Info, LineNo, [Ch|Acc])
-      end
-  end.
-
-raw_write(F, A, Info, File, Content) ->
-  TypeInfo = get_type_string(F, A, Info, file),
-  ContentList = lists:reverse(Content) ++ TypeInfo ++ "\n",
-  ContentBin = list_to_binary(ContentList),
-  file:write_file(File, ContentBin, [append]).
-
-get_type_string(F, A, Info, Mode) ->
-  Type = get_type_info({F,A}, Info#info.typeMap),
-  TypeStr =
-    case Type of
-      {contract, C} -> 
-        dialyzer_contracts:contract_to_string(C);
-      {RetType, ArgType} ->
-        dialyzer_utils:format_sig(erl_types:t_fun(ArgType, RetType),
-				  Info#info.recMap)
-    end,
-  case Info#info.contracts of
-    true ->
-      case {Mode, Type} of
-	{file, {contract, _}} -> "";
-	_ ->
-	  Prefix = lists:concat(["-spec ", F]),
-	  lists:concat([Prefix, TypeStr, "."])
-      end;
-    false ->
-      Prefix = lists:concat(["%% @spec ", F]),
-      lists:concat([Prefix, TypeStr, "."])
-  end.
- 
-show_type_info_only(File, Info) ->
-  io:format("\n%% File: ~p\n%% ", [File]),
-  OutputString = lists:concat(["~.", length(File)+8, "c~n"]),
-  io:fwrite(OutputString, [$-]),
-  Fun = fun ({_LineNo, F, A}) ->
-	    TypeInfo = get_type_string(F, A, Info, show),
-	    io:format("~s\n", [TypeInfo])
-	end,
-  lists:foreach(Fun, Info#info.funcs).
-
-get_type_info(Func, TypeMap) ->
-  case typer_map:lookup(Func, TypeMap) of
-    none ->
-      %% Note: Typeinfo of any function should exist in
-      %% the result offered by dialyzer, otherwise there 
-      %% *must* be something wrong with the analysis
-      io:format("No type info for function: ~p\n", [Func]),
-      halt();
-    {contract, _Fun} = C -> C;
-    {_RetType, _ArgType} = RA -> RA 
-  end.
diff --git a/lib/typer/src/typer_info.erl b/lib/typer/src/typer_info.erl
deleted file mode 100644
index ea25fa6f68..0000000000
--- a/lib/typer/src/typer_info.erl
+++ /dev/null
@@ -1,162 +0,0 @@
-%% -*- erlang-indent-level: 2 -*-
-%%
-%% %CopyrightBegin%
-%% 
-%% Copyright Ericsson AB 2006-2009. All Rights Reserved.
-%% 
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
-%% 
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
-%% 
-%% %CopyrightEnd%
-%%
-
--module(typer_info).
-
--export([collect/1]).
-
--type func_info() :: {non_neg_integer(), atom(), arity()}.
--type inc_file_info() :: {string(), func_info()}.
-
--record(tmpAcc, {file		:: string(),
-		 module		:: atom(),
-		 funcAcc=[]	:: [func_info()],
-		 incFuncAcc=[]	:: [inc_file_info()],
-		 dialyzerObj=[] :: [{mfa(), {_, _}}]}).
-
--include("typer.hrl").
-
--spec collect(#typer_analysis{}) -> #typer_analysis{}.
-
-collect(Analysis) ->
-  NewPlt =
-    try get_dialyzer_plt(Analysis) of
-	DialyzerPlt ->
-	dialyzer_plt:merge_plts([Analysis#typer_analysis.trust_plt, DialyzerPlt])
-    catch
-      throw:{dialyzer_error,_Reason} ->
-	typer:error("Dialyzer's PLT is missing or is not up-to-date; please (re)create it")
-    end,
-  NewAnalysis = lists:foldl(fun collect_one_file_info/2, 
-			    Analysis#typer_analysis{trust_plt = NewPlt}, 
-			    Analysis#typer_analysis.ana_files),
-  %% Process Remote Types
-  TmpCServer = NewAnalysis#typer_analysis.code_server,
-  NewCServer =
-    try
-      NewRecords = dialyzer_codeserver:get_temp_records(TmpCServer),
-      OldRecords = dialyzer_plt:get_types(NewPlt),
-      MergedRecords = dialyzer_utils:merge_records(NewRecords, OldRecords),
-      %% io:format("Merged Records ~p",[MergedRecords]),
-      TmpCServer1 = dialyzer_codeserver:set_temp_records(MergedRecords, TmpCServer),
-      TmpCServer2 = dialyzer_utils:process_record_remote_types(TmpCServer1),
-      dialyzer_contracts:process_contract_remote_types(TmpCServer2)
-    catch
-      throw:{error, ErrorMsg} ->
-	typer:error(ErrorMsg)
-    end,
-  NewAnalysis#typer_analysis{code_server = NewCServer}.
-
-collect_one_file_info(File, Analysis) ->
-  Ds = [{d,Name,Val} || {Name,Val} <- Analysis#typer_analysis.macros],
-  %% Current directory should also be included in "Includes".
-  Includes = [filename:dirname(File)|Analysis#typer_analysis.includes],
-  Is = [{i,Dir} || Dir <- Includes],
-  Options = dialyzer_utils:src_compiler_opts() ++ Is ++ Ds,
-  case dialyzer_utils:get_abstract_code_from_src(File, Options) of
-    {error, Reason} ->
-      %% io:format("File=~p\n,Options=~p\n,Error=~p\n", [File,Options,Reason]),
-      typer:compile_error(Reason);
-    {ok, AbstractCode} ->
-      case dialyzer_utils:get_core_from_abstract_code(AbstractCode, Options) of
-	error -> typer:compile_error(["Could not get core erlang for "++File]);
-	{ok, Core} ->
-	  case dialyzer_utils:get_record_and_type_info(AbstractCode) of
-	    {error, Reason} -> typer:compile_error([Reason]);
-	    {ok, Records} -> 
-	      Mod = list_to_atom(filename:basename(File, ".erl")),
-	      case dialyzer_utils:get_spec_info(Mod, AbstractCode, Records) of
-		{error, Reason} -> typer:compile_error([Reason]);
-		{ok, SpecInfo} -> 
-		  analyze_core_tree(Core, Records, SpecInfo, Analysis, File)
-	      end
-	  end
-      end
-  end.
-
-analyze_core_tree(Core, Records, SpecInfo, Analysis, File) ->
-  Module = list_to_atom(filename:basename(File, ".erl")),
-  TmpTree = cerl:from_records(Core),
-  CS1 = Analysis#typer_analysis.code_server,
-  NextLabel = dialyzer_codeserver:get_next_core_label(CS1),
-  {Tree, NewLabel} = cerl_trees:label(TmpTree, NextLabel),
-  CS2 = dialyzer_codeserver:insert(Module, Tree, CS1),
-  CS3 = dialyzer_codeserver:set_next_core_label(NewLabel, CS2),
-  CS4 = dialyzer_codeserver:store_temp_records(Module, Records, CS3),
-  CS5 = dialyzer_codeserver:store_temp_contracts(Module, SpecInfo, CS4),
-  Ex_Funcs = [{0,F,A} || {_,_,{F,A}} <- cerl:module_exports(Tree)],
-  TmpCG = Analysis#typer_analysis.callgraph,
-  CG = dialyzer_callgraph:scan_core_tree(Tree, TmpCG),
-  Fun = fun analyze_one_function/2,
-  All_Defs = cerl:module_defs(Tree),
-  Acc = lists:foldl(Fun, #tmpAcc{file=File, module=Module}, All_Defs),
-  Exported_FuncMap = typer_map:insert({File, Ex_Funcs},
-				      Analysis#typer_analysis.ex_func),
-  %% NOTE: we must sort all functions in the file which
-  %% originate from this file by *numerical order* of lineNo
-  Sorted_Functions = lists:keysort(1, Acc#tmpAcc.funcAcc),
-  FuncMap = typer_map:insert({File, Sorted_Functions},
-			     Analysis#typer_analysis.func),
-  %% NOTE: However we do not need to sort functions
-  %% which are imported from included files.
-  IncFuncMap = typer_map:insert({File, Acc#tmpAcc.incFuncAcc}, 
-				Analysis#typer_analysis.inc_func),
-  Final_Files = Analysis#typer_analysis.final_files ++ [{File, Module}],
-  RecordMap = typer_map:insert({File, Records}, Analysis#typer_analysis.record),
-  Analysis#typer_analysis{final_files=Final_Files,
-			  callgraph=CG,
-			  code_server=CS5,
-			  ex_func=Exported_FuncMap,
-			  inc_func=IncFuncMap,
-			  record=RecordMap,
-			  func=FuncMap}.
-
-analyze_one_function({Var, FunBody} = Function, Acc) ->
-  F = cerl:fname_id(Var),
-  A = cerl:fname_arity(Var),
-  TmpDialyzerObj = {{Acc#tmpAcc.module, F, A}, Function},
-  NewDialyzerObj = Acc#tmpAcc.dialyzerObj ++ [TmpDialyzerObj],  
-  [_, LineNo, {file, FileName}] = cerl:get_ann(FunBody),
-  BaseName = filename:basename(FileName),
-  FuncInfo = {LineNo, F, A},
-  OriginalName = Acc#tmpAcc.file,
-  {FuncAcc, IncFuncAcc} =
-    case (FileName =:= OriginalName) orelse (BaseName =:= OriginalName) of
-      true -> %% Coming from original file
-	%% io:format("Added function ~p\n", [{LineNo, F, A}]),
-	{Acc#tmpAcc.funcAcc ++ [FuncInfo], Acc#tmpAcc.incFuncAcc};
-      false ->
-	%% Coming from other sourses, including:
-	%%     -- .yrl (yecc-generated file)
-	%%     -- yeccpre.hrl (yecc-generated file)
-	%%     -- other cases
-	{Acc#tmpAcc.funcAcc, Acc#tmpAcc.incFuncAcc ++ [{FileName, FuncInfo}]}
-    end,
-  Acc#tmpAcc{funcAcc = FuncAcc,
-	     incFuncAcc = IncFuncAcc,
-	     dialyzerObj = NewDialyzerObj}.
-
-get_dialyzer_plt(#typer_analysis{plt = PltFile0}) ->
-  PltFile =
-    case PltFile0 =:= none of
-      true -> dialyzer_plt:get_default_plt();
-      false -> PltFile0
-    end,
-  dialyzer_plt:from_file(PltFile).
diff --git a/lib/typer/src/typer_map.erl b/lib/typer/src/typer_map.erl
deleted file mode 100644
index bf62dea651..0000000000
--- a/lib/typer/src/typer_map.erl
+++ /dev/null
@@ -1,47 +0,0 @@
-%% -*- erlang-indent-level: 2 -*-
-%%
-%% %CopyrightBegin%
-%% 
-%% Copyright Ericsson AB 2006-2009. All Rights Reserved.
-%% 
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
-%% 
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
-%% 
-%% %CopyrightEnd%
-%%
--module(typer_map).
-
--export([new/0, insert/2, lookup/2, from_list/1, remove/2, fold/3]).
-
--spec new() -> dict().
-new() ->
-  dict:new().
-
--spec insert({term(), term()}, dict()) -> dict().
-insert(Object, Dict) ->
-  {Key, Value} = Object,
-  dict:store(Key, Value, Dict).
-
--spec lookup(term(), dict()) -> any().
-lookup(Key, Dict) ->
-  try dict:fetch(Key, Dict) catch error:_ -> none end.
-
--spec from_list([{term(), term()}]) -> dict().
-from_list(List) ->
-  dict:from_list(List).
-
--spec remove(term(), dict()) -> dict().
-remove(Key, Dict) ->
-  dict:erase(Key, Dict).
-
--spec fold(fun((term(), term(), term()) -> term()), term(), dict()) -> term().
-fold(Fun, Acc0, Dict) -> 
-  dict:fold(Fun, Acc0, Dict).
diff --git a/lib/typer/src/typer_options.erl b/lib/typer/src/typer_options.erl
deleted file mode 100644
index 1e53b1b305..0000000000
--- a/lib/typer/src/typer_options.erl
+++ /dev/null
@@ -1,191 +0,0 @@
-%% -*- erlang-indent-level: 2 -*-
-%%
-%% %CopyrightBegin%
-%% 
-%% Copyright Ericsson AB 2006-2009. All Rights Reserved.
-%% 
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
-%% 
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
-%% 
-%% %CopyrightEnd%
-%%
-%%===========================================================================
-%% File        : typer_options.erl
-%% Author      : Bingwen He <[email protected]>
-%% Description : Handles all command-line options given to TypEr
-%%===========================================================================
-
--module(typer_options).
-
--export([process/0]).
-
-%%---------------------------------------------------------------------------
-
--include("typer.hrl").
-
-%%---------------------------------------------------------------------------
-%% Exported functions
-%%---------------------------------------------------------------------------
-
--spec process() -> {#args{}, #typer_analysis{}}.
-
-process() ->
-  ArgList = init:get_plain_arguments(),
-  %% io:format("Args is ~p\n",[Args]),
-  {Args, Analysis} = analyze_args(ArgList, #args{}, #typer_analysis{}),
-  %% if the mode has not been set, set it to the default mode (show)
-  {Args, case Analysis#typer_analysis.mode of
-	   undefined -> Analysis#typer_analysis{mode = ?SHOW};
-	   Mode when is_atom(Mode) -> Analysis
-	 end}.
-
-%%---------------------------------------------------------------------------
-%% Internal functions
-%%---------------------------------------------------------------------------
-
-analyze_args([], Args, Analysis) ->
-  {Args, Analysis};
-analyze_args(ArgList, Args, Analysis) ->
-  {Result, Rest} = cl(ArgList),
-  {NewArgs, NewAnalysis} = analyze_result(Result, Args, Analysis),
-  analyze_args(Rest, NewArgs, NewAnalysis).
-
-cl(["-h"|_])     -> help_message();
-cl(["--help"|_]) -> help_message();
-cl(["-v"|_])        -> version_message();
-cl(["--version"|_]) -> version_message();
-cl(["--comments"|Opts]) -> {comments, Opts};
-cl(["--show"|Opts]) -> {{mode, ?SHOW}, Opts};
-cl(["--show_exported"|Opts]) -> {{mode, ?SHOW_EXPORTED}, Opts};
-cl(["--show-exported"|Opts]) -> {{mode, ?SHOW_EXPORTED}, Opts};
-cl(["--annotate"|Opts]) -> {{mode, ?ANNOTATE}, Opts};
-cl(["--annotate-inc-files"|Opts]) -> {{mode, ?ANNOTATE_INC_FILES}, Opts};
-cl(["--plt",Plt|Opts]) -> {{plt, Plt}, Opts};
-cl(["-D"++Def|Opts]) ->
-  case Def of
-    "" -> typer:error("no variable name specified after -D");
-    _ ->
-      L = re:split(Def, "=", [{return, list}]),
-      DefPair = process_def_list(L),
-      {{def, DefPair}, Opts}
-  end;
-cl(["-I",Dir|Opts]) -> {{inc,Dir}, Opts};
-cl(["-I"++Dir|Opts]) ->
-  case Dir of
-    "" -> typer:error("no include directory specified after -I");
-    _ -> {{inc, Dir}, Opts}
-  end;
-cl(["-T"|Opts]) ->
-  {Files, RestOpts} = dialyzer_cl_parse:collect_args(Opts),
-  case Files of
-    [] -> typer:error("no file or directory specified after -T");
-    [_|_] -> {{trust, Files}, RestOpts}
-  end;
-cl(["-r"|Opts]) ->
-  {Files, RestOpts} = dialyzer_cl_parse:collect_args(Opts),
-  {{a_dir_r, Files}, RestOpts};
-cl(["-"++H|_]) -> typer:error("unknown option -"++H);
-cl(Opts) -> 
-  {Args, RestOpts} = dialyzer_cl_parse:collect_args(Opts),
-  {{analyze, Args}, RestOpts}.
-
-process_def_list(L) ->
-  case L of
-    [Name, Value] ->
-      {ok, Tokens, _} = erl_scan:string(Value ++ "."),
-      {ok, ErlValue} = erl_parse:parse_term(Tokens),
-      {list_to_atom(Name), ErlValue};
-    [Name] ->
-      {list_to_atom(Name), true}
-  end.
-
-%% Get information about files that the user trusts and wants to analyze
-analyze_result({analyze, Val}, Args, Analysis) -> 
-  NewVal = Args#args.analyze ++ Val,
-  {Args#args{analyze = NewVal}, Analysis};
-analyze_result({a_dir_r, Val}, Args, Analysis) -> 
-  NewVal = Args#args.analyzed_dir_r ++ Val,
-  {Args#args{analyzed_dir_r = NewVal}, Analysis};
-analyze_result({trust, Val}, Args, Analysis) -> 
-  NewVal = Args#args.trust ++ Val,
-  {Args#args{trust = NewVal}, Analysis};
-analyze_result(comments, Args, Analysis) ->
-  {Args, Analysis#typer_analysis{contracts = false}};
-%% Get useful information for actual analysis
-analyze_result({mode, Val}, Args, Analysis) -> 
-  case Analysis#typer_analysis.mode of
-    undefined -> {Args, Analysis#typer_analysis{mode = Val}};
-    _ -> mode_error()
-  end;
-analyze_result({def, Val}, Args, Analysis) ->
-  NewVal = Analysis#typer_analysis.macros ++ [Val],
-  {Args, Analysis#typer_analysis{macros = NewVal}};
-analyze_result({inc, Val}, Args, Analysis) -> 
-  NewVal = Analysis#typer_analysis.includes ++ [Val],
-  {Args, Analysis#typer_analysis{includes = NewVal}};
-analyze_result({plt, Plt}, Args, Analysis) ->
-  {Args, Analysis#typer_analysis{plt = Plt}}.
-
-%%--------------------------------------------------------------------
-
--spec mode_error() -> no_return().
-mode_error() ->
-  typer:error("can not do \"show\", \"show-exported\", \"annotate\", and \"annotate-inc-files\" at the same time").
-
--spec version_message() -> no_return().
-version_message() ->
-  io:format("TypEr version "++?VSN++"\n"),
-  erlang:halt(0).
-
--spec help_message() -> no_return().
-help_message() ->
-  S = " Usage: typer [--help] [--version] [--comments] [--plt PLT]
-              [--show | --show-exported | --annotate | --annotate-inc-files]
-              [-Ddefine]* [-I include_dir]* [-T application]* [-r] file*
-
- Options:
-   -r dir*
-       search directories recursively for .erl files below them
-   --show
-       Prints type specifications for all functions on stdout.
-       (this is the default behaviour; this option is not really needed)
-   --show-exported (or --show_exported)
-       Same as --show, but prints specifications for exported functions only
-       Specs are displayed sorted alphabetically on the function's name
-   --annotate
-       Annotates the specified files with type specifications
-   --annotate-inc-files
-       Same as --annotate but annotates all -include() files as well as
-       all .erl files (use this option with caution - has not been tested much)
-   --comments
-       Prints type information using Edoc comments, not type specs
-   --plt PLT
-       Use the specified dialyzer PLT file rather than the default one
-   -T file*
-       The specified file(s) already contain type specifications and these
-       are to be trusted in order to print specs for the rest of the files
-       (Multiple files or dirs, separated by spaces, can be specified.)
-   -Dname (or -Dname=value)
-       pass the defined name(s) to TypEr
-       (The syntax of defines is the same as that used by \"erlc\".)
-   -I include_dir
-       pass the include_dir to TypEr
-       (The syntax of includes is the same as that used by \"erlc\".)
-   --version (or -v)
-       prints the Typer version and exits
-   --help (or -h)
-       prints this message and exits
-
- Note:
-   * denotes that multiple occurrences of these options are possible.
-",
-  io:put_chars(S),
-  erlang:halt(0).
diff --git a/lib/typer/src/typer_preprocess.erl b/lib/typer/src/typer_preprocess.erl
deleted file mode 100644
index 7cb0b9932b..0000000000
--- a/lib/typer/src/typer_preprocess.erl
+++ /dev/null
@@ -1,154 +0,0 @@
-%% -*- erlang-indent-level: 2 -*-
-%%
-%% %CopyrightBegin%
-%% 
-%% Copyright Ericsson AB 2006-2009. All Rights Reserved.
-%% 
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
-%% 
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
-%% 
-%% %CopyrightEnd%
-%%
-
--module(typer_preprocess).
-
--export([get_all_files/2]).
-
--include("typer.hrl").
-
-%%----------------------------------------------------------------------------
-
--spec get_all_files(#args{}, 'analysis' | 'trust') -> [string()].
-
-get_all_files(Args, analysis) ->
-  case internal_get_all_files(Args#args.analyze,
-			      Args#args.analyzed_dir_r,
-			      fun test_erl_file_exclude_ann/1) of
-    [] -> typer:error("no file(s) to analyze");
-    AllFiles -> AllFiles
-  end;
-get_all_files(Args, trust) -> 
-  internal_get_all_files(Args#args.trust, [], fun test_erl_file/1).
-
--spec test_erl_file_exclude_ann(string()) -> boolean().
-
-test_erl_file_exclude_ann(File) ->
-  case filename:extension(File) of
-    ".erl" -> %% Exclude files ending with ".ann.erl"
-      case re:run(File, "[\.]ann[\.]erl$") of
-	{match, _} -> false;
-	nomatch -> true
-      end;
-    _ -> false
-  end.
-
--spec test_erl_file(string()) -> boolean().
-
-test_erl_file(File) ->
-  filename:extension(File) =:= ".erl".
-
--spec internal_get_all_files([string()], [string()],
-			     fun((string()) -> boolean())) -> [string()].
-
-internal_get_all_files(File_Dir, Dir_R, Fun) ->
-  All_File_1 = process_file_and_dir(File_Dir, Fun),
-  All_File_2 = process_dir_recursively(Dir_R, Fun),
-  remove_dup(All_File_1 ++ All_File_2).
-
--spec process_file_and_dir([string()],
-			   fun((string()) -> boolean())) -> [string()].
-
-process_file_and_dir(File_Dir, TestFun) ->
-  Fun =
-    fun (Elem, Acc) ->
-	case filelib:is_regular(Elem) of
-	  true  -> process_file(Elem, TestFun, Acc);
-	  false -> check_dir(Elem, non_recursive, Acc, TestFun)
-	end
-    end,
-  lists:foldl(Fun, [], File_Dir).
-
--spec process_dir_recursively([string()],
-			      fun((string()) -> boolean())) -> [string()].
-
-process_dir_recursively(Dirs, TestFun) ->
-  Fun = fun (Dir, Acc) ->
-	    check_dir(Dir, recursive, Acc, TestFun)
-	end,
-  lists:foldl(Fun, [], Dirs).
-
--spec check_dir(string(),
-		'non_recursive' | 'recursive',
-		[string()],
-		fun((string()) -> boolean())) -> [string()].
-
-check_dir(Dir, Mode, Acc, Fun) ->
-  case file:list_dir(Dir) of
-    {ok, Files} ->
-      {TmpDirs, TmpFiles} = split_dirs_and_files(Files, Dir),
-      case Mode of
-	non_recursive ->
-	  FinalFiles = process_file_and_dir(TmpFiles, Fun),
-	  Acc ++ FinalFiles;
-	recursive ->
-	  TmpAcc1 = process_file_and_dir(TmpFiles, Fun),
-	  TmpAcc2 = process_dir_recursively(TmpDirs, Fun),
-	  Acc ++ TmpAcc1 ++ TmpAcc2
-      end;
-    {error, eacces} ->
-      typer:error("no access permission to dir \""++Dir++"\"");
-    {error, enoent} ->
-      typer:error("cannot access "++Dir++": No such file or directory");
-    {error, _Reason} ->
-      typer:error("error involving a use of file:list_dir/1")
-  end.
-
-%% Same order as the input list
--spec process_file(string(), fun((string()) -> boolean()), string()) -> [string()].
-
-process_file(File, TestFun, Acc) ->
-  case TestFun(File) of
-    true  -> Acc ++ [File];
-    false -> Acc
-  end.
-
-%% Same order as the input list
--spec split_dirs_and_files([string()], string()) -> {[string()], [string()]}.
-
-split_dirs_and_files(Elems, Dir) ->
-  Test_Fun =
-    fun (Elem, {DirAcc, FileAcc}) ->
-	File = filename:join(Dir, Elem),
-	case filelib:is_regular(File) of
-	  false -> {[File|DirAcc], FileAcc}; 
-	  true  -> {DirAcc, [File|FileAcc]}
-	end
-    end,
-  {Dirs, Files} = lists:foldl(Test_Fun, {[], []}, Elems),
-  {lists:reverse(Dirs), lists:reverse(Files)}.  
-
-%%-----------------------------------------------------------------------
-%% Utilities
-%%-----------------------------------------------------------------------
-
-%% Removes duplicate filenames but it keeps the order of the input list
-
--spec remove_dup([string()]) -> [string()].
-
-remove_dup(Files) ->
-  Test_Dup = fun (File, Acc) ->
-		 case lists:member(File, Acc) of
-		   true  -> Acc;
-		   false -> [File|Acc]
-		 end
-	     end,
-  Reversed_Elems = lists:foldl(Test_Dup, [], Files),
-  lists:reverse(Reversed_Elems).
diff --git a/lib/typer/vsn.mk b/lib/typer/vsn.mk
index 7f4aabb335..51561939ac 100644
--- a/lib/typer/vsn.mk
+++ b/lib/typer/vsn.mk
@@ -1 +1 @@
-TYPER_VSN = 0.1.7.5
+TYPER_VSN = 0.9