Changeset 1561

Timestamp:

05/26/10 14:22:06 (15 years ago)

Author:

rsinfu

Message:

Added code for bugzilla 3909: toDelegate handles only a tiny subset of function pointer types.

The bug is not completely fixed. toDelegate() still does not work well with @safe function pointers... because toDelegate() is unsafe. And variadic arguments are ignored.

Files:

• trunk/phobos/std/functional.d (modified) (2 diffs)
• trunk/phobos/std/traits.d (modified) (1 diff)
• trunk/phobos/std/typecons.d (modified) (5 diffs)

trunk/phobos/std/functional.d

@@ -507 +507 @@
-    // assert(compose!(baz, `to!(int)(a) + 1`, foo)(1) == 2.5);
-    // assert(compose!(baz, bar)("1"[]) == 2.5);
-    
-    // @@@BUG@@@
-    //assert(compose!(baz, bar)("1") == 2.5);
-
-    // @@@BUG@@@
-    //assert(compose!(`a + 0.5`, `to!(int)(a) + 1`, foo)(1) == 2.5);
-}
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-}
-
-/**Convert a callable to a delegate with the same parameter list and
- * return type, avoiding heap allocations and use of auxiliary storage.
- *
- * Examples:
- * ---
- * void doStuff() {
- *     writeln("Hello, world.");
- * }
- *
- * void runDelegate(void delegate() myDelegate) {
- *     myDelegate();
- * }
- *
- * auto delegateToPass = toDelegate(&doStuff);
- * runDelegate(delegateToPass);  // Calls doStuff, prints "Hello, world."
- * ---
- *
-
+
+
+
+
+
- */
-auto toDelegate(F)(auto ref F fp) if (isCallable!(F)) {
-
-    static if (is(F == delegate))
-    {
-        return fp;
-    }
-    else static if (is(typeof(&F.opCall) == delegate)
-                || (is(typeof(&F.opCall) V : V*) && is(V == function)))
-    {
-        return toDelegate(&fp.opCall);
-    }
-    else
-    {
-
-
-
-
-
-
-
-
+
-
-        static struct DelegateFields {
-            union {
-                DelType del;
-                //pragma(msg, typeof(del));
-
-                struct {
-                    void* contextPtr;
-                    void* funcPtr;
-                }
-            }
-        }
-
-        // fp is stored in the returned delegate's context pointer.
-        // The returned delegate's function pointer points to
-        // DelegateFaker.doIt.
-        DelegateFields df;
-
-        df.contextPtr = cast(void*) fp;
-
-ReturnType!(F), ParameterTypeTuple!(F)
+F
-        auto dummyDel = &(dummy.doIt);
-        df.funcPtr = dummyDel.funcptr;
-
-        return df.del;
-    }
-}
-
-unittest {
-    static int inc(ref uint num) {
-        num++;
@@ -621 +652 @@
-    static assert(!is(typeof(&s1.opCall) == delegate));
-    S1 s1;
-    auto getvals1 = toDelegate(s1);
-    assert(getvals1() == 4);
-    
-    struct S2 { static int opCall() { return 123456; } }
-    static assert(!is(typeof(&S2.opCall) == delegate));
-    S2 s2;
-    auto getvals2 =&S2.opCall;
-    assert(getvals2() == 123456);
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

trunk/phobos/std/traits.d

@@ -2014 +2014 @@
-    static assert(isTypeTuple!(typeof(func)));
-    static assert(isTypeTuple!(int, char, double));
-
-    static assert(! isTypeTuple!(c));
-    static assert(! isTypeTuple!(isTypeTuple));
-    static assert(! isTypeTuple!(CONST));
-}
-
-
-/**
+Detect whether symbol or type $(D T) is a function pointer.
+ */
+template isFunctionPointer(T...)
+    if (T.length == 1)
+{
+    static if (is(T[0] U) || is(typeof(T[0]) U))
+    {
+        static if (is(U F : F*) && is(F == function))
+            enum bool isFunctionPointer = true;
+        else
+            enum bool isFunctionPointer = false;
+    }
+    else
+        enum bool isFunctionPointer = false;
+}
+
+unittest
+{
+    static void foo() {}
+    void bar() {}
+
+    auto fpfoo = &foo;
+    static assert(isFunctionPointer!(fpfoo));
+    static assert(isFunctionPointer!(void function()));
+
+    auto dgbar = &bar;
+    static assert(! isFunctionPointer!(dgbar));
+    static assert(! isFunctionPointer!(void delegate()));
+    static assert(! isFunctionPointer!(foo));
+    static assert(! isFunctionPointer!(bar));
+}
+
+
+/**
-Detect whether symbol or type $(D T) is a function, a function pointer or a delegate.
- */
-template isSomeFunction(T...)
-    if (T.length == 1)
-{
-    static if (is(typeof(& T[0]) U : U*) && is(U == function))
-    {
-        // T is a function symbol.
-        enum bool isSomeFunction = true;
-    }

trunk/phobos/std/typecons.d

@@ -1529 +1529 @@
-}
-
-
-/**
-$(D AutoImplement) automatically implements (by default) all abstract member
-functions in the class or interface $(D Base) in specified way.
-
-Params:
-  how  = template which specifies _how functions will be implemented/overridden.
-
-first one is the $(D Base),
-and the second one is an alias to a function to be implemented.  Then
-$(D how) must return a implemented 
+type $(D Base) and an alias
+to an implemented function.  Then $(D how) must return an implemented
+
-
-         The generated function body can use these keywords:
-         $(UL
-            $(LI $(D a0), $(D a1), …: arguments passed to the function;)
-            $(LI $(D args): a tuple of the arguments;)
-            $(LI $(D self): an alias to the function itself;)
-            $(LI $(D parent): an alias to the overridden function (if any).)
-         )
-
-        You may want to use templated property functions (instead of Implicit
@@ -1766 +1766 @@
-    {
-        // base class identifier which generated code should use
-        enum string BASE_CLASS_ID = baseName;
-
-        // FuncInfo instance identifier which generated code should use
-        template FUNCINFO_ID(string name, size_t i)
-        {
-            enum string FUNCINFO_ID =
-                myName ~ "." ~ INTERNAL_FUNCINFO_ID!(name, i);
-        }
-
-        // preferred identifier for i-th parameter variable
-        template PARAMETER_VARIABLE_ID(size_t i)
-        {
-            enum string PARAMETER_VARIABLE_ID = "a" ~ toStringNow!(i);
-        }
-    }
-
-    /* Policy configurations for generating constructors. */
-    template ConstructorGeneratingPolicy()
-    {
-        mixin CommonGeneratingPolicy;
-
-        /* Generates constructor body.  Just forward to the base class' one. */
-        string generateFunctionBody(ctor.../+[BUG 4217]+/)() @property
-        {
@@ -1871 +1865 @@
-        static class C_6
-        {
-            this(int n) { assert(n == 42); }
-            this(string s) { assert(s == "Deeee"); }
-            this(...) {}
-        }
-        auto o1 = new BlackHole!C_6(42);
-        auto o2 = new BlackHole!C_6("Deeee");
-        auto o3 = new BlackHole!C_6(1, 2, 3, 4);
-    }
+    // attributes
+    {
+        interface I_7
+        {
+            ref int test_ref();
+            int test_pure() pure;
+            int test_nothrow() nothrow;
+            int test_property() @property;
+            int test_safe() @safe;
+            int test_trusted() @trusted;
+            int test_system() @system;
+            int test_pure_nothrow() pure nothrow;
+        }
+        auto o = new BlackHole!I_7;
+    }
+    // storage classes
+    {
+        interface I_8
+        {
+            void test_const() const;
+            void test_immutable() immutable;
+            void test_shared() shared;
+            void test_shared_const() shared const;
+        }
+        auto o = new BlackHole!I_8;
+    }
-    /+ // deep inheritance
-    {
-    // XXX [BUG 2525,3525]
-    // NOTE: [r494] func.c(504-571) FuncDeclaration::semantic()
-        interface I { void foo(); }
-        interface J : I {}
-        interface K : J {}
-8
-8
+9
+9
-    }+/
-}
-
-
-/*
-Used by MemberFunctionGenerator.
- */
-rivat
+ackag
-{
-    enum string name = nam;
-    alias T contents;
-}
-
-/*
-Used by MemberFunctionGenerator.
- */
-rivat
+ackag
-{
-    alias         ReturnType!(T) RT;
-    alias ParameterTypeTuple!(T) PT;
-}
+package template FuncInfo(Func)
+{
+    alias         ReturnType!(Func) RT;
+    alias ParameterTypeTuple!(Func) PT;
+}
-
-/*
-General-purpose member function generator.
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-{
-private static:
-    //mixin Policy; // can't
-
-    //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::://
-    // Internal stuffs
-    //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::://
-
-    enum CONSTRUCTOR_NAME = "__ctor";
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-    // Returns a tuple consisting of 0,1,2,...,n-1.  For static foreach.
-    template CountUp(size_t n)
-    {
-        static if (n > 0)
-            alias TypeTuple!(CountUp!(n - 1), n - 1) CountUp;
-        else
-            alias TypeTuple!() CountUp;
-    }
-
@@ -1969 +2034 @@
-
-    // handle each overload set
-    private string generateCodeForOverloadSet(alias oset)() @property
-    {
-        string code = "";
-
-        foreach (i_; CountUp!(0 + oset.contents.length)) // workaround
-        {
-            enum i = 0 + i_; // workaround
-            code ~= generateFunction!(
-
+
+
-        }
-        return code;
-    }
-
-    /*
-     * Returns D code which implements the function func.  This function
-     * actually generates only the declarator part; the function body part is
-     * generated by the functionGenerator() policy.
-     */
-
-
-
-
-
-
+
+
+
-        enum isCtor = (name == CONSTRUCTOR_NAME);
-
-        string code; // the result
-
-        /*** Function Declarator ***/
-        {
+            alias FunctionTypeOf!(func) Func;
-            alias FunctionAttribute FA;
-            enum atts     = functionAttributes!(func);
-            enum realName = isCtor ? "this" : name;
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-            static string make_postAtts()
-            {
-                string poatts = "";
-                if (atts & FA.PURE    ) poatts ~= " pure";
-                if (atts & FA.NOTHROW ) poatts ~= " nothrow";
-                if (atts & FA.PROPERTY) poatts ~= " @property";
-                if (atts & FA.SAFE    ) poatts ~= " @safe";
-                if (atts & FA.TRUSTED ) poatts ~= " @trusted";
-                return poatts;
-            }
-            enum postAtts = make_postAtts();
-
-
+
+
-            {
-
-
-
-
-
-
-
-
+
+
+
+
+
-            }
-returnType = make_returnType
+storageClass = make_storageClass
-
-            //
-
+ %s
-                    functionLinkage!(func),
-                    returnType,
-                    realName,
-func, myFuncInfo
-
+myFuncInfo, func
+, storageClass
-        }
-
-        /*** Function Body ***/
-        code ~= "{\n";
-        {
-            enum nparams = ParameterTypeTuple!(func).length;
-
-            /* Declare keywords: args, self and parent. */
-            string preamble;
-
-            preamble ~= "alias TypeTuple!(" ~ enumerateParameters!(nparams) ~ ") args;\n";
-            if (!isCtor)
-            {
-                preamble ~= "alias " ~ name ~ " self;\n";
-                if (WITH_BASE_CLASS && !__traits(isAbstractFunction, func))
-                    //preamble ~= "alias super." ~ name ~ " parent;\n"; // [BUG 2540]
-                    preamble ~= "auto parent = &super." ~ name ~ ";\n";
-            }
-
-
+
+
+
+
+
+
-            code ~= preamble;
-Policy.generateFunctionBody!(func)
+fbody
-        }
-        code ~= "}";
-
-        return code;
-    }
-
-    /*
-     * Returns D code which declares function parameters.
-     * "ref int a0, real a1, ..."
-     */
-
-
-
-
-
+
+
-        alias ParameterStorageClass STC;
-        alias ParameterStorageClassTuple!(func) stcs;
-        enum nparams = stcs.length;
-
-        string params = ""; // the result
-
-        foreach (i, stc; stcs)
-        {
-            if (i > 0) params ~= ", ";
-
-            // Parameter storage classes.
-            if (stc & STC.SCOPE) params ~= "scope ";
-            if (stc & STC.OUT  ) params ~= "out ";
-            if (stc & STC.REF  ) params ~= "ref ";
-            if (stc & STC.LAZY ) params ~= "lazy ";
-
-            // Take parameter type from the FuncInfo.
-            params ~= myFuncInfo ~ ".PT[" ~ toStringNow!(i) ~ "]";
-
-            // Declare a parameter variable.
-olicy.P
+
-        }
-
-        // Add some ellipsis part if needed.
-        final switch (variadicFunctionStyle!(func))
-        {
-            case Variadic.NO:
-                break;
-
-            case Variadic.C, Variadic.D:
-                // (...) or (a, b, ...)
@@ -2117 +2197 @@
-    // Returns D code which enumerates n parameter variables using comma as the
-    // separator.  "a0, a1, a2, a3"
-    private string enumerateParameters(size_t n)() @property
-    {
-        string params = "";
-
-        foreach (i_; CountUp!(n))
-        {
-            enum i = 0 + i_; // workaround
-            if (i > 0) params ~= ", ";
-olicy.P
+
-        }
-        return params;
-    }
-}
-
-
-/**
-Predefined how-policies for $(D AutoImplement).  These templates are used by
-$(D BlackHole) and $(D WhiteHole), respectively.
- */