Change all the function attributes from func_* -> __*__. This gets rid

of func_name, func_dict and func_doc as they already exist as __name__,
__dict__ and __doc__.

4 files changed, 27 insertions, 29 deletions

diff --git a/Doc/lib/libdis.tex b/Doc/lib/libdis.tex
index 3f00fa8..84841e4 100644
--- a/Doc/lib/libdis.tex
+++ b/Doc/lib/libdis.tex
@@ -622,7 +622,7 @@ default parameters, which are found below TOS.
 \end{opcodedesc}
 
 \begin{opcodedesc}{MAKE_CLOSURE}{argc}
-Creates a new function object, sets its \var{func_closure} slot, and
+Creates a new function object, sets its \var{__closure__} slot, and
 pushes it on the stack.  TOS is the code associated with the function.
 If the code object has N free variables, the next N items on the stack
 are the cells for these variables.  The function also has \var{argc}
diff --git a/Doc/lib/libinspect.tex b/Doc/lib/libinspect.tex
index 85651f0..c9a63fc 100644
--- a/Doc/lib/libinspect.tex
+++ b/Doc/lib/libinspect.tex
@@ -45,11 +45,9 @@ you can expect to find the following special attributes:
   \hline
   \lineiv{function}{__doc__}{documentation string}{}
   \lineiv{}{__name__}{name with which this function was defined}{}
-  \lineiv{}{func_code}{code object containing compiled function bytecode}{}
-  \lineiv{}{func_defaults}{tuple of any default values for arguments}{}
-  \lineiv{}{func_doc}{(same as __doc__)}{}
-  \lineiv{}{func_globals}{global namespace in which this function was defined}{}
-  \lineiv{}{func_name}{(same as __name__)}{}
+  \lineiv{}{__code__}{code object containing compiled function bytecode}{}
+  \lineiv{}{__defaults__}{tuple of any default values for arguments}{}
+  \lineiv{}{__globals__}{global namespace in which this function was defined}{}
   \hline
   \lineiv{traceback}{tb_frame}{frame object at this level}{}
   \lineiv{}{tb_lasti}{index of last attempted instruction in bytecode}{}
diff --git a/Doc/lib/libstdtypes.tex b/Doc/lib/libstdtypes.tex
index cc117ab..f3ce92a 100644
--- a/Doc/lib/libstdtypes.tex
+++ b/Doc/lib/libstdtypes.tex
@@ -1964,10 +1964,10 @@ Code objects are used by the implementation to represent
 They differ from function objects because they don't contain a
 reference to their global execution environment.  Code objects are
 returned by the built-in \function{compile()} function and can be
-extracted from function objects through their \member{func_code}
+extracted from function objects through their \member{__code__}
 attribute.
 \bifuncindex{compile}
-\withsubitem{(function object attribute)}{\ttindex{func_code}}
+\withsubitem{(function object attribute)}{\ttindex{__code__}}
 
 A code object can be executed or evaluated by passing it (instead of a
 source string) to the \function{exec()} or \function{eval()} 
diff --git a/Doc/ref/ref3.tex b/Doc/ref/ref3.tex
index 4b9da9e..6bd60c9 100644
--- a/Doc/ref/ref3.tex
+++ b/Doc/ref/ref3.tex
@@ -473,42 +473,42 @@ parameter list.
 Special attributes: 
 
 \begin{tableiii}{lll}{member}{Attribute}{Meaning}{}
-  \lineiii{func_doc}{The function's documentation string, or
+  \lineiii{__doc__}{The function's documentation string, or
     \code{None} if unavailable}{Writable}
 
-  \lineiii{__doc__}{Another way of spelling
-    \member{func_doc}}{Writable}
-
-  \lineiii{func_name}{The function's name}{Writable}
-
-  \lineiii{__name__}{Another way of spelling
-    \member{func_name}}{Writable}
+  \lineiii{__name__}{The function's name}{Writable}
 
   \lineiii{__module__}{The name of the module the function was defined
     in, or \code{None} if unavailable.}{Writable}
 
-  \lineiii{func_defaults}{A tuple containing default argument values
+  \lineiii{__defaults__}{A tuple containing default argument values
     for those arguments that have defaults, or \code{None} if no
     arguments have a default value}{Writable}
 
-  \lineiii{func_code}{The code object representing the compiled
+  \lineiii{__code__}{The code object representing the compiled
     function body.}{Writable}
 
-  \lineiii{func_globals}{A reference to the dictionary that holds the
+  \lineiii{__globals__}{A reference to the dictionary that holds the
     function's global variables --- the global namespace of the module
     in which the function was defined.}{Read-only}
 
-  \lineiii{func_dict}{The namespace supporting arbitrary function
+  \lineiii{__dict__}{The namespace supporting arbitrary function
     attributes.}{Writable}
 
-  \lineiii{func_closure}{\code{None} or a tuple of cells that contain
+  \lineiii{__closure__}{\code{None} or a tuple of cells that contain
     bindings for the function's free variables.}{Read-only}
+
+  \lineiii{__annotations__}{A dict containing annotations of parameters.}
+    {Writable}
+
+  \lineiii{__kwdefaults__}{A dict containing defaults for keyword-only
+    parameters.}{Writable}
 \end{tableiii}
 
 Most of the attributes labelled ``Writable'' check the type of the
 assigned value.
 
-\versionchanged[\code{func_name} is now writable]{2.4}
+\versionchanged[\code{__name__} is now writable]{2.4}
 
 Function objects also support getting and setting arbitrary
 attributes, which can be used, for example, to attach metadata to
@@ -521,16 +521,16 @@ Additional information about a function's definition can be retrieved
 from its code object; see the description of internal types below.
 
 \withsubitem{(function attribute)}{
-  \ttindex{func_doc}
   \ttindex{__doc__}
   \ttindex{__name__}
   \ttindex{__module__}
   \ttindex{__dict__}
-  \ttindex{func_defaults}
-  \ttindex{func_closure}
-  \ttindex{func_code}
-  \ttindex{func_globals}
-  \ttindex{func_dict}}
+  \ttindex{__defaults__}
+  \ttindex{__closure__}
+  \ttindex{__code__}
+  \ttindex{__globals__}
+  \ttindex{__annotations__}
+  \ttindex{__kwdefaults__}
 \indexii{global}{namespace}
 
 \item[User-defined methods]
@@ -700,7 +700,7 @@ Modules are imported by the \keyword{import} statement (see
 section~\ref{import}, ``The \keyword{import} statement'').%
 \stindex{import}\obindex{module}
 A module object has a namespace implemented by a dictionary object
-(this is the dictionary referenced by the func_globals attribute of
+(this is the dictionary referenced by the __globals__ attribute of
 functions defined in the module).  Attribute references are translated
 to lookups in this dictionary, e.g., \code{m.x} is equivalent to
 \code{m.__dict__["x"]}.