diff -r de2b96f220a5 Lib/test/test_inspect.py
--- a/Lib/test/test_inspect.py	Sat Jan 25 00:00:28 2014 -0500
+++ b/Lib/test/test_inspect.py	Sat Jan 25 19:41:31 2014 +1000
@@ -1,4 +1,5 @@
 import _testcapi
+import builtins
 import collections
 import datetime
 import functools
@@ -1650,6 +1651,37 @@
             __call__ = type
         test_callable(ThisWorksNow())
 
+    @unittest.skipIf(MISSING_C_DOCSTRINGS,
+                     "Signature information for builtins requires docstrings")
+    def test_builtins_have_signatures(self):
+        # This checks all builtin callables have signatures
+        # A couple have signatures Signature can't handle, so we skip those
+        no_signature = ["range", "slice"]
+        # And some are just low priority for conversion...
+        postponed = ["__build_class__"]
+        ns = vars(builtins)
+        for name, obj in sorted(ns.items()):
+            if not callable(obj):
+                continue
+            if name in no_signature:
+                continue
+            if name in postponed:
+                continue
+            if isinstance(obj, type) and issubclass(obj, BaseException):
+                # Postpone converting the exception types
+                continue
+            if isinstance(obj, type):
+                # Also postpone converting all other types for the moment
+                continue
+            with self.subTest(builtin=name):
+                self.assertIsNotNone(inspect.signature(obj))
+        # Check functions that can't be represented don't claim a signature
+        for name in no_signature:
+            # Can't test this yet, see http://bugs.python.org/issue20326
+            return
+            with self.subTest(builtin=name):
+                self.assertIsNone(ns[name].__text_signature__)
+
 
     def test_signature_on_builtins_no_signature(self):
         with self.assertRaisesRegex(ValueError, 'no signature found for builtin'):
diff -r de2b96f220a5 Python/bltinmodule.c
--- a/Python/bltinmodule.c	Sat Jan 25 00:00:28 2014 -0500
+++ b/Python/bltinmodule.c	Sat Jan 25 19:41:31 2014 +1000
@@ -229,25 +229,58 @@
 is the number of parent directories to search relative to the current module.");
 
 
+/*[clinic input]
+abs as builtin_abs
+
+    x: 'O'
+    /
+
+Return the absolute value of the argument.
+[clinic start generated code]*/
+
+PyDoc_STRVAR(builtin_abs__doc__,
+"abs(module, x)\n"
+"Return the absolute value of the argument.");
+
+#define BUILTIN_ABS_METHODDEF    \
+    {"abs", (PyCFunction)builtin_abs, METH_O, builtin_abs__doc__},
+
 static PyObject *
-builtin_abs(PyObject *self, PyObject *v)
+builtin_abs(PyModuleDef *module, PyObject *x)
+/*[clinic end generated code: checksum=39a49de51b4714d5ea858c85075f4f422b208af1]*/
 {
-    return PyNumber_Absolute(v);
+    return PyNumber_Absolute(x);
 }
 
-PyDoc_STRVAR(abs_doc,
-"abs(number) -> number\n\
-\n\
-Return the absolute value of the argument.");
+/*[clinic input]
+all as builtin_all
+
+    iterable: 'O'
+    /
+
+Return True if bool(x) is True for all values x in the iterable.
+
+If the iterable is empty, return True.
+[clinic start generated code]*/
+
+PyDoc_STRVAR(builtin_all__doc__,
+"all(module, iterable)\n"
+"Return True if bool(x) is True for all values x in the iterable.\n"
+"\n"
+"If the iterable is empty, return True.");
+
+#define BUILTIN_ALL_METHODDEF    \
+    {"all", (PyCFunction)builtin_all, METH_O, builtin_all__doc__},
 
 static PyObject *
-builtin_all(PyObject *self, PyObject *v)
+builtin_all(PyModuleDef *module, PyObject *iterable)
+/*[clinic end generated code: checksum=0a79c5483de04809e4176eb5ca46685c2443e657]*/
 {
     PyObject *it, *item;
     PyObject *(*iternext)(PyObject *);
     int cmp;
 
-    it = PyObject_GetIter(v);
+    it = PyObject_GetIter(iterable);
     if (it == NULL)
         return NULL;
     iternext = *Py_TYPE(it)->tp_iternext;
@@ -277,20 +310,35 @@
     Py_RETURN_TRUE;
 }
 
-PyDoc_STRVAR(all_doc,
-"all(iterable) -> bool\n\
-\n\
-Return True if bool(x) is True for all values x in the iterable.\n\
-If the iterable is empty, return True.");
+/*[clinic input]
+any as builtin_any
+
+    iterable: 'O'
+    /
+
+Return True if bool(x) is True for any x in the iterable.
+
+If the iterable is empty, return False.
+[clinic start generated code]*/
+
+PyDoc_STRVAR(builtin_any__doc__,
+"any(module, iterable)\n"
+"Return True if bool(x) is True for any x in the iterable.\n"
+"\n"
+"If the iterable is empty, return False.");
+
+#define BUILTIN_ANY_METHODDEF    \
+    {"any", (PyCFunction)builtin_any, METH_O, builtin_any__doc__},
 
 static PyObject *
-builtin_any(PyObject *self, PyObject *v)
+builtin_any(PyModuleDef *module, PyObject *iterable)
+/*[clinic end generated code: checksum=401a08de3cf8403ea725fa4d65c847f3a5053342]*/
 {
     PyObject *it, *item;
     PyObject *(*iternext)(PyObject *);
     int cmp;
 
-    it = PyObject_GetIter(v);
+    it = PyObject_GetIter(iterable);
     if (it == NULL)
         return NULL;
     iternext = *Py_TYPE(it)->tp_iternext;
@@ -320,56 +368,99 @@
     Py_RETURN_FALSE;
 }
 
-PyDoc_STRVAR(any_doc,
-"any(iterable) -> bool\n\
-\n\
-Return True if bool(x) is True for any x in the iterable.\n\
-If the iterable is empty, return False.");
+/*[clinic input]
+ascii as builtin_ascii
+
+    object: 'O'
+    /
+
+Return an ASCII-only representation of an object.
+
+As repr(), return a string containing a printable representation of an
+object, but escape the non-ASCII characters in the string returned by
+repr() using \\x, \\u or \\U escapes. This generates a string similar
+to that returned by repr() in Python 2.
+[clinic start generated code]*/
+
+PyDoc_STRVAR(builtin_ascii__doc__,
+"ascii(module, object)\n"
+"Return an ASCII-only representation of an object.\n"
+"\n"
+"As repr(), return a string containing a printable representation of an\n"
+"object, but escape the non-ASCII characters in the string returned by\n"
+"repr() using \\x, \\u or \\U escapes. This generates a string similar\n"
+"to that returned by repr() in Python 2.");
+
+#define BUILTIN_ASCII_METHODDEF    \
+    {"ascii", (PyCFunction)builtin_ascii, METH_O, builtin_ascii__doc__},
 
 static PyObject *
-builtin_ascii(PyObject *self, PyObject *v)
+builtin_ascii(PyModuleDef *module, PyObject *object)
+/*[clinic end generated code: checksum=e9d56c39257868c6e56bea58d47c7a5b0c256d4f]*/
 {
-    return PyObject_ASCII(v);
+    return PyObject_ASCII(object);
 }
 
-PyDoc_STRVAR(ascii_doc,
-"ascii(object) -> string\n\
-\n\
-As repr(), return a string containing a printable representation of an\n\
-object, but escape the non-ASCII characters in the string returned by\n\
-repr() using \\x, \\u or \\U escapes.  This generates a string similar\n\
-to that returned by repr() in Python 2.");
 
+/*[clinic input]
+bin as builtin_bin
+
+    number: 'O'
+    /
+
+Return the binary representation of an integer.
+
+   >>> bin(2796202)
+   '0b1010101010101010101010'
+[clinic start generated code]*/
+
+PyDoc_STRVAR(builtin_bin__doc__,
+"bin(module, number)\n"
+"Return the binary representation of an integer.\n"
+"\n"
+"   >>> bin(2796202)\n"
+"   \'0b1010101010101010101010\'");
+
+#define BUILTIN_BIN_METHODDEF    \
+    {"bin", (PyCFunction)builtin_bin, METH_O, builtin_bin__doc__},
 
 static PyObject *
-builtin_bin(PyObject *self, PyObject *v)
+builtin_bin(PyModuleDef *module, PyObject *number)
+/*[clinic end generated code: checksum=fdfb9aca6f7bd21ce19110503416ba2d2b38feab]*/
 {
-    return PyNumber_ToBase(v, 2);
+    return PyNumber_ToBase(number, 2);
 }
 
-PyDoc_STRVAR(bin_doc,
-"bin(number) -> string\n\
-\n\
-Return the binary representation of an integer.\n\
-\n\
-   >>> bin(2796202)\n\
-   '0b1010101010101010101010'\n\
-");
 
+/*[clinic input]
+callable as builtin_callable
+
+    object: 'O'
+    /
+
+Return whether the object is callable (i.e., some kind of function).
+
+Note that classes are callable, as are instances of classes with a
+__call__() method.
+[clinic start generated code]*/
+
+PyDoc_STRVAR(builtin_callable__doc__,
+"callable(module, object)\n"
+"Return whether the object is callable (i.e., some kind of function).\n"
+"\n"
+"Note that classes are callable, as are instances of classes with a\n"
+"__call__() method.");
+
+#define BUILTIN_CALLABLE_METHODDEF    \
+    {"callable", (PyCFunction)builtin_callable, METH_O, builtin_callable__doc__},
 
 static PyObject *
-builtin_callable(PyObject *self, PyObject *v)
+builtin_callable(PyModuleDef *module, PyObject *object)
+/*[clinic end generated code: checksum=79491b118d5e81660082897285408979832e40d3]*/
 {
-    return PyBool_FromLong((long)PyCallable_Check(v));
+    return PyBool_FromLong((long)PyCallable_Check(object));
 }
 
-PyDoc_STRVAR(callable_doc,
-"callable(object) -> bool\n\
-\n\
-Return whether the object is callable (i.e., some kind of function).\n\
-Note that classes are callable, as are instances of classes with a\n\
-__call__() method.");
-
 
 typedef struct {
     PyObject_HEAD
@@ -524,39 +615,95 @@
 };
 
 
+/*[clinic input]
+format as builtin_format
+
+    value: 'O'
+    format_spec: unicode(c_default="NULL") = ''
+    /
+
+Returns value.__format__(format_spec)
+
+format_spec defaults to the empty string
+[clinic start generated code]*/
+
+PyDoc_STRVAR(builtin_format__doc__,
+"format(module, value, format_spec=\'\')\n"
+"Returns value.__format__(format_spec)\n"
+"\n"
+"format_spec defaults to the empty string");
+
+#define BUILTIN_FORMAT_METHODDEF    \
+    {"format", (PyCFunction)builtin_format, METH_VARARGS, builtin_format__doc__},
+
 static PyObject *
-builtin_format(PyObject *self, PyObject *args)
+builtin_format_impl(PyModuleDef *module, PyObject *value, PyObject *format_spec);
+
+static PyObject *
+builtin_format(PyModuleDef *module, PyObject *args)
 {
+    PyObject *return_value = NULL;
     PyObject *value;
     PyObject *format_spec = NULL;
 
-    if (!PyArg_ParseTuple(args, "O|U:format", &value, &format_spec))
-        return NULL;
+    if (!PyArg_ParseTuple(args,
+        "O|U:format",
+        &value, &format_spec))
+        goto exit;
+    return_value = builtin_format_impl(module, value, format_spec);
 
+exit:
+    return return_value;
+}
+
+static PyObject *
+builtin_format_impl(PyModuleDef *module, PyObject *value, PyObject *format_spec)
+/*[clinic end generated code: checksum=b580dfcd2d4eb1176fd211fa30b33a5157b48800]*/
+{
     return PyObject_Format(value, format_spec);
 }
 
-PyDoc_STRVAR(format_doc,
-"format(value[, format_spec]) -> string\n\
-\n\
-Returns value.__format__(format_spec)\n\
-format_spec defaults to \"\"");
+/*[clinic input]
+chr as builtin_chr
+
+    i: 'i'
+    /
+
+Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.
+[clinic start generated code]*/
+
+PyDoc_STRVAR(builtin_chr__doc__,
+"chr(module, i)\n"
+"Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.");
+
+#define BUILTIN_CHR_METHODDEF    \
+    {"chr", (PyCFunction)builtin_chr, METH_VARARGS, builtin_chr__doc__},
 
 static PyObject *
-builtin_chr(PyObject *self, PyObject *args)
+builtin_chr_impl(PyModuleDef *module, int i);
+
+static PyObject *
+builtin_chr(PyModuleDef *module, PyObject *args)
 {
-    int x;
+    PyObject *return_value = NULL;
+    int i;
 
-    if (!PyArg_ParseTuple(args, "i:chr", &x))
-        return NULL;
+    if (!PyArg_ParseTuple(args,
+        "i:chr",
+        &i))
+        goto exit;
+    return_value = builtin_chr_impl(module, i);
 
-    return PyUnicode_FromOrdinal(x);
+exit:
+    return return_value;
 }
 
-PyDoc_STRVAR(chr_doc,
-"chr(i) -> Unicode character\n\
-\n\
-Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.");
+static PyObject *
+builtin_chr_impl(PyModuleDef *module, int i)
+/*[clinic end generated code: checksum=5e0a4ae42b7d2fc948f4f1015965b20574e177e3]*/
+{
+    return PyUnicode_FromOrdinal(i);
+}
 
 
 static char *
@@ -589,34 +736,87 @@
     return str;
 }
 
+/*[clinic input]
+compile as builtin_compile
+
+    source: 'O'
+    filename: object(converter="PyUnicode_FSDecoder")
+    mode: 's'
+    flags: 'i' = 0
+    dont_inherit: 'i' = 0
+    optimize: 'i' = -1
+
+Compile source into a code object that can be executed by exec() or eval().
+
+The source code may represent a Python module, statement or expression.
+The filename will be used for run-time error messages.
+The mode must be 'exec' to compile a module, 'single' to compile a
+single (interactive) statement, or 'eval' to compile an expression.
+The flags argument, if present, controls which future statements influence
+the compilation of the code.
+The dont_inherit argument, if non-zero, stops the compilation inheriting
+the effects of any future statements in effect in the code calling
+compile; if absent or zero these statements do influence the compilation,
+in addition to any features explicitly specified.
+[clinic start generated code]*/
+
+PyDoc_STRVAR(builtin_compile__doc__,
+"compile(module, source, filename, mode, flags=0, dont_inherit=0, optimize=-1)\n"
+"Compile source into a code object that can be executed by exec() or eval().\n"
+"\n"
+"The source code may represent a Python module, statement or expression.\n"
+"The filename will be used for run-time error messages.\n"
+"The mode must be \'exec\' to compile a module, \'single\' to compile a\n"
+"single (interactive) statement, or \'eval\' to compile an expression.\n"
+"The flags argument, if present, controls which future statements influence\n"
+"the compilation of the code.\n"
+"The dont_inherit argument, if non-zero, stops the compilation inheriting\n"
+"the effects of any future statements in effect in the code calling\n"
+"compile; if absent or zero these statements do influence the compilation,\n"
+"in addition to any features explicitly specified.");
+
+#define BUILTIN_COMPILE_METHODDEF    \
+    {"compile", (PyCFunction)builtin_compile, METH_VARARGS|METH_KEYWORDS, builtin_compile__doc__},
+
 static PyObject *
-builtin_compile(PyObject *self, PyObject *args, PyObject *kwds)
+builtin_compile_impl(PyModuleDef *module, PyObject *source, PyObject *filename, const char *mode, int flags, int dont_inherit, int optimize);
+
+static PyObject *
+builtin_compile(PyModuleDef *module, PyObject *args, PyObject *kwargs)
+{
+    PyObject *return_value = NULL;
+    static char *_keywords[] = {"source", "filename", "mode", "flags", "dont_inherit", "optimize", NULL};
+    PyObject *source;
+    PyObject *filename;
+    const char *mode;
+    int flags = 0;
+    int dont_inherit = 0;
+    int optimize = -1;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+        "OO&s|iii:compile", _keywords,
+        &source, PyUnicode_FSDecoder, &filename, &mode, &flags, &dont_inherit, &optimize))
+        goto exit;
+    return_value = builtin_compile_impl(module, source, filename, mode, flags, dont_inherit, optimize);
+
+exit:
+    return return_value;
+}
+
+static PyObject *
+builtin_compile_impl(PyModuleDef *module, PyObject *source, PyObject *filename, const char *mode, int flags, int dont_inherit, int optimize)
+/*[clinic end generated code: checksum=a1d9dae93c8ae0044425dc7abb6f7fbabcc960f8]*/
 {
     char *str;
-    PyObject *filename;
-    char *startstr;
-    int mode = -1;
-    int dont_inherit = 0;
-    int supplied_flags = 0;
-    int optimize = -1;
+    int compile_mode = -1;
     int is_ast;
     PyCompilerFlags cf;
-    PyObject *cmd;
-    static char *kwlist[] = {"source", "filename", "mode", "flags",
-                             "dont_inherit", "optimize", NULL};
     int start[] = {Py_file_input, Py_eval_input, Py_single_input};
     PyObject *result;
 
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO&s|iii:compile",  kwlist,
-                                     &cmd,
-                                     PyUnicode_FSDecoder, &filename,
-                                     &startstr, &supplied_flags,
-                                     &dont_inherit, &optimize))
-        return NULL;
+    cf.cf_flags = flags | PyCF_SOURCE_IS_UTF8;
 
-    cf.cf_flags = supplied_flags | PyCF_SOURCE_IS_UTF8;
-
-    if (supplied_flags &
+    if (flags &
         ~(PyCF_MASK | PyCF_MASK_OBSOLETE | PyCF_DONT_IMPLY_DEDENT | PyCF_ONLY_AST))
     {
         PyErr_SetString(PyExc_ValueError,
@@ -635,25 +835,25 @@
         PyEval_MergeCompilerFlags(&cf);
     }
 
-    if (strcmp(startstr, "exec") == 0)
-        mode = 0;
-    else if (strcmp(startstr, "eval") == 0)
-        mode = 1;
-    else if (strcmp(startstr, "single") == 0)
-        mode = 2;
+    if (strcmp(mode, "exec") == 0)
+        compile_mode = 0;
+    else if (strcmp(mode, "eval") == 0)
+        compile_mode = 1;
+    else if (strcmp(mode, "single") == 0)
+        compile_mode = 2;
     else {
         PyErr_SetString(PyExc_ValueError,
-                        "compile() arg 3 must be 'exec', 'eval' or 'single'");
+                        "compile() mode must be 'exec', 'eval' or 'single'");
         goto error;
     }
 
-    is_ast = PyAST_Check(cmd);
+    is_ast = PyAST_Check(source);
     if (is_ast == -1)
         goto error;
     if (is_ast) {
-        if (supplied_flags & PyCF_ONLY_AST) {
-            Py_INCREF(cmd);
-            result = cmd;
+        if (flags & PyCF_ONLY_AST) {
+            Py_INCREF(source);
+            result = source;
         }
         else {
             PyArena *arena;
@@ -662,7 +862,7 @@
             arena = PyArena_New();
             if (arena == NULL)
                 goto error;
-            mod = PyAST_obj2mod(cmd, arena, mode);
+            mod = PyAST_obj2mod(source, arena, compile_mode);
             if (mod == NULL) {
                 PyArena_Free(arena);
                 goto error;
@@ -678,11 +878,11 @@
         goto finally;
     }
 
-    str = source_as_string(cmd, "compile", "string, bytes or AST", &cf);
+    str = source_as_string(source, "compile", "string, bytes or AST", &cf);
     if (str == NULL)
         goto error;
 
-    result = Py_CompileStringObject(str, filename, start[mode], &cf, optimize);
+    result = Py_CompileStringObject(str, filename, start[compile_mode], &cf, optimize);
     goto finally;
 
 error:
@@ -692,21 +892,6 @@
     return result;
 }
 
-PyDoc_STRVAR(compile_doc,
-"compile(source, filename, mode[, flags[, dont_inherit]]) -> code object\n\
-\n\
-Compile the source (a Python module, statement or expression)\n\
-into a code object that can be executed by exec() or eval().\n\
-The filename will be used for run-time error messages.\n\
-The mode must be 'exec' to compile a module, 'single' to compile a\n\
-single (interactive) statement, or 'eval' to compile an expression.\n\
-The flags argument, if present, controls which future statements influence\n\
-the compilation of the code.\n\
-The dont_inherit argument, if non-zero, stops the compilation inheriting\n\
-the effects of any future statements in effect in the code calling\n\
-compile; if absent or zero these statements do influence the compilation,\n\
-in addition to any features explicitly specified.");
-
 static PyObject *
 builtin_dir(PyObject *self, PyObject *args)
 {
@@ -2386,20 +2571,20 @@
     {"__build_class__", (PyCFunction)builtin___build_class__,
      METH_VARARGS | METH_KEYWORDS, build_class_doc},
     {"__import__",      (PyCFunction)builtin___import__, METH_VARARGS | METH_KEYWORDS, import_doc},
-    {"abs",             builtin_abs,        METH_O, abs_doc},
-    {"all",             builtin_all,        METH_O, all_doc},
-    {"any",             builtin_any,        METH_O, any_doc},
-    {"ascii",           builtin_ascii,      METH_O, ascii_doc},
-    {"bin",             builtin_bin,        METH_O, bin_doc},
-    {"callable",        builtin_callable,   METH_O, callable_doc},
-    {"chr",             builtin_chr,        METH_VARARGS, chr_doc},
-    {"compile",         (PyCFunction)builtin_compile,    METH_VARARGS | METH_KEYWORDS, compile_doc},
+    BUILTIN_ABS_METHODDEF
+    BUILTIN_ALL_METHODDEF
+    BUILTIN_ANY_METHODDEF
+    BUILTIN_ASCII_METHODDEF
+    BUILTIN_BIN_METHODDEF
+    BUILTIN_CALLABLE_METHODDEF
+    BUILTIN_CHR_METHODDEF
+    BUILTIN_COMPILE_METHODDEF
     {"delattr",         builtin_delattr,    METH_VARARGS, delattr_doc},
     {"dir",             builtin_dir,        METH_VARARGS, dir_doc},
     {"divmod",          builtin_divmod,     METH_VARARGS, divmod_doc},
     {"eval",            builtin_eval,       METH_VARARGS, eval_doc},
     {"exec",        builtin_exec,       METH_VARARGS, exec_doc},
-    {"format",          builtin_format,     METH_VARARGS, format_doc},
+    BUILTIN_FORMAT_METHODDEF
     {"getattr",         builtin_getattr,    METH_VARARGS, getattr_doc},
     {"globals",         (PyCFunction)builtin_globals,    METH_NOARGS, globals_doc},
     {"hasattr",         builtin_hasattr,    METH_VARARGS, hasattr_doc},