Index: src/AST/Util.cpp
===================================================================
--- src/AST/Util.cpp	(revision d9147506b415deb55496d73aa7ef7402f22fab90)
+++ src/AST/Util.cpp	(revision 6174ecc742d3800f0a71962e3e54fc334b9e774b)
@@ -260,4 +260,5 @@
 			}
 		}
+		if ( ! type->assertions.empty() ) visit_children = false;
 	}
 
Index: src/Parser/TypeData.cpp
===================================================================
--- src/Parser/TypeData.cpp	(revision d9147506b415deb55496d73aa7ef7402f22fab90)
+++ src/Parser/TypeData.cpp	(revision 6174ecc742d3800f0a71962e3e54fc334b9e774b)
@@ -1585,8 +1585,29 @@
 	buildParamList( td->function.params, params );
 	buildForall( td->forall, forall );
-	// Functions do not store their assertions there anymore.
+	// Functions do not store their assertions there anymore.  <-- FIXME: clarify or remove this comment
+	// Assertions were parsed as belonging to the type that preceded them.
+	// forall ( T | is_foo(T), U | are_bar(T, U) )
+	//   => parse
+	// forall( [ typarm( T, [is_foo(T)] ), typarm( U, [are_bar(T, U)] ) ] )
+	//   => now, flatten as
+	// forall( [ T, U ] ), assns( [ is_foo(T), are_bar(T, U)] )
 	for ( ast::ptr<ast::TypeDecl> & type_param : forall ) {
 		auto mut = type_param.get_and_mutate();
 		splice( assertions, mut->assertions );
+	}
+	// When assertions without a type preceding them were parsed, placeholder
+	// types were invented to hold them.
+	// forall ( | is_foo(), U | is_bar(U) )
+	//   => parse
+	// forall( [ typarm( PLCHLD, [is_foo()] ), typarm( U, [is_bar(U)] ) ] )
+	//   => prev step
+	// forall( [ PLCHLD, U ] ), assns( [ is_foo(), is_bar(U)] )
+	//   => now, remove the placeholders
+	// forall( [ U ] ), assns( [ is_foo(), is_bar(U)] )
+	for (std::vector<ast::ptr<ast::TypeDecl>>::iterator it = forall.begin();
+			it != forall.end(); ) {
+		// placeholder types have empty names
+		if ( (*it)->name == "" ) it = forall.erase(it);
+		else ++it;
 	}
 	if ( td->base ) {
Index: src/Parser/parser.yy
===================================================================
--- src/Parser/parser.yy	(revision d9147506b415deb55496d73aa7ef7402f22fab90)
+++ src/Parser/parser.yy	(revision 6174ecc742d3800f0a71962e3e54fc334b9e774b)
@@ -3132,5 +3132,6 @@
 	// | type_specifier identifier_parameter_declarator
 	| assertion_list
-		{ $$ = DeclarationNode::newTypeParam( ast::TypeDecl::Dtype, new string( DeclarationNode::anonymous.newName() ) )->addAssertions( $1 ); }
+		// Invent a placeholder type to wrap these bare assertions.  Rely on buildFunctionDecl to remove the placeholder.
+		{ $$ = DeclarationNode::newTypeParam( ast::TypeDecl::Dtype, new string( "" ) )->addAssertions( $1 ); }
 	| ENUM '(' identifier_or_type_name ')' identifier_or_type_name new_type_class type_initializer_opt assertion_list_opt
 		{	
Index: src/SymTab/Mangler.cpp
===================================================================
--- src/SymTab/Mangler.cpp	(revision d9147506b415deb55496d73aa7ef7402f22fab90)
+++ src/SymTab/Mangler.cpp	(revision 6174ecc742d3800f0a71962e3e54fc334b9e774b)
@@ -290,5 +290,5 @@
 	if ( typeMode ) return;
 	auto funcType = dynamic_cast<const ast::FunctionType *>( type );
-	if ( funcType && !funcType->forall.empty() ) {
+	if ( funcType && (!funcType->forall.empty() || !funcType->assertions.empty()) ) {
 		std::list< std::string > assertionNames;
 		int dcount = 0, fcount = 0, vcount = 0, acount = 0;
Index: tests/.expect/poly-bare-assn.txt
===================================================================
--- tests/.expect/poly-bare-assn.txt	(revision 6174ecc742d3800f0a71962e3e54fc334b9e774b)
+++ tests/.expect/poly-bare-assn.txt	(revision 6174ecc742d3800f0a71962e3e54fc334b9e774b)
@@ -0,0 +1,2 @@
+the world is boring
+this is the world; this is fun
Index: tests/poly-bare-assn.cfa
===================================================================
--- tests/poly-bare-assn.cfa	(revision 6174ecc742d3800f0a71962e3e54fc334b9e774b)
+++ tests/poly-bare-assn.cfa	(revision 6174ecc742d3800f0a71962e3e54fc334b9e774b)
@@ -0,0 +1,125 @@
+// A bare assertion is one that occurs without any here-bound type variables.
+// The test shows that bare assertions can occur on a function or on a type,
+// without introducing any "fake" type variables.
+
+// Related to Trac #185.
+// Present state, the test (in a test.py run) shows a fix of the #185
+// sub-case where there two overloads, already differentiated by other factors,
+// and one of them gets a bare assertion, without being charged a polymorphism
+// cost.  The two "still required" points following do not run under test.py.
+
+// Still required to fix 185: parse bare assertions on traits
+#ifdef TRY_MISSING_SYNTAX
+#define MAYBE_SYNTAX(...) __VA_ARGS__
+#else
+#define MAYBE_SYNTAX(...)
+#endif
+
+// Still required to fix 185: support bare assertions on types (orig 185 repro)
+#ifdef TRY_BROKEN_TYPE
+#define MAYBE_TYPE(...) __VA_ARGS__
+#else
+#define MAYBE_TYPE(...)
+#endif
+
+MAYBE_TYPE (
+    forall ( | {void fun();} ) {
+
+        struct thing {};
+
+        void ?{}( thing & this ) {
+            fun();
+        }
+    }
+)
+
+void greet() {
+    printf("the world is boring\n");
+}
+
+forall ( | {void fun();} )
+void greet() {
+    printf("this is the world; ");
+    fun();
+}
+
+MAYBE_SYNTAX(
+    trait world_is_fun() { void fun(); }
+
+    MAYBE_TYPE(
+        forall ( | world_is_fun() ) {
+
+            struct thing2 {};
+
+            void ?{}( thing2 & this ) {
+                fun();
+            }
+        }
+    )
+
+    void greet2() {
+        printf("the galaxy is boring\n");
+    }
+
+    forall ( | {void fun();} )
+    void greet2() {
+        printf("this is the galaxy; ");
+        fun();
+    }
+)
+
+void greetworld_nofun() {
+    greet();
+}
+
+MAYBE_SYNTAX(
+    void greetgalaxy_nofun() {
+        greet2();
+    }
+)
+
+void fun() {
+    printf("this is fun\n");
+}
+
+void greetworld_withfun() {
+    greet();
+}
+
+MAYBE_SYNTAX(
+    void greetgalaxy_withfun() {
+        greet2();
+    }
+)
+
+MAYBE_TYPE(
+    // A type declared with a bare assertion can be used ("instantiated") without
+    // adding type arguments.  You shouldn't have to provide any type arguments
+    // when you use it because it was decalred with no type parameters.
+    void test_type() {
+        thing x;   (void) x;
+    #ifdef TRY_MISSING_SYNTAX
+        thing2 y;  (void) y;
+    #endif
+    }
+)
+
+// A function overload declared with a bare assertion is called when the
+// assertion is satisfied.  Your cost calculation should not have the asserting
+// overload incur the penalty of a type variable because it was decalred with
+// no type parameters.
+void test_costs() {
+    greetworld_nofun();
+    greetworld_withfun();
+  MAYBE_SYNTAX(
+    greetgalaxy_nofun();
+    greetgalaxy_withfun();
+  )
+}
+
+int main() {
+  MAYBE_TYPE(
+    test_type();
+  )
+    test_costs();
+}