diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4c0caf2..e05e736 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,7 @@
+# 1.0.3
+
+* Preserve type arguments in generic function-typed parameters (#613).
+
 # 1.0.2
 
 * Support new generic function typedef syntax (#563).
diff --git a/bin/format.dart b/bin/format.dart
index 976c12f..3de323c 100644
--- a/bin/format.dart
+++ b/bin/format.dart
@@ -14,7 +14,7 @@
 import 'package:dart_style/src/source_code.dart';
 
 // Note: The following line of code is modified by tool/grind.dart.
-const version = "1.0.2";
+const version = "1.0.3";
 
 void main(List<String> args) {
   var parser = new ArgParser(allowTrailingOptions: true);
diff --git a/lib/src/source_visitor.dart b/lib/src/source_visitor.dart
index 0d7a35a..213f7a4 100644
--- a/lib/src/source_visitor.dart
+++ b/lib/src/source_visitor.dart
@@ -1176,7 +1176,7 @@
       // Try to keep the function's parameters with its name.
       builder.startSpan();
       visit(node.identifier);
-      visit(node.parameters);
+      _visitParameterSignature(node.typeParameters, node.parameters);
       builder.endSpan();
     });
   }
diff --git a/pubspec.yaml b/pubspec.yaml
index 229dce5..a20a9b3 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -1,6 +1,6 @@
 name: dart_style
 # Note: See tool/grind.dart for how to bump the version.
-version: 1.0.2
+version: 1.0.3
 author: Dart Team <misc@dartlang.org>
 description: Opinionated, automatic Dart source code formatter.
 homepage: https://github.com/dart-lang/dart_style
diff --git a/test/regression/0600/0613.unit b/test/regression/0600/0613.unit
new file mode 100644
index 0000000..8656dfa
--- /dev/null
+++ b/test/regression/0600/0613.unit
@@ -0,0 +1,4 @@
+>>>
+void takeIdentityFunction(T id<T>(T x)) {}
+<<<
+void takeIdentityFunction(T id<T>(T x)) {}
\ No newline at end of file
diff --git a/test/splitting/generic_method_parameters.unit b/test/splitting/generic_method_parameters.unit
index 3463343..c7a2c36 100644
--- a/test/splitting/generic_method_parameters.unit
+++ b/test/splitting/generic_method_parameters.unit
@@ -62,4 +62,16 @@
             LongTypeParameterS>(
         longParameter1,
         longParameter2) =>
-    body;
\ No newline at end of file
+    body;
+>>> generic function typed parameter
+longFunctionName(String longParameterName<LongTypeParameter,
+AnotherTypeParam>(LongTypeParameter parameter, AnotherTypeParam another)) {;}
+<<<
+longFunctionName(
+    String longParameterName<
+            LongTypeParameter,
+            AnotherTypeParam>(
+        LongTypeParameter parameter,
+        AnotherTypeParam another)) {
+  ;
+}
\ No newline at end of file
diff --git a/test/whitespace/functions.unit b/test/whitespace/functions.unit
index 206ec2b..6638651 100644
--- a/test/whitespace/functions.unit
+++ b/test/whitespace/functions.unit
@@ -161,4 +161,8 @@
   ) {
     ;
   });
-}
\ No newline at end of file
+}
+>>> generic function typed parameter
+function(int   foo  <  T  ,S >(T t, S s)) {}
+<<<
+function(int foo<T, S>(T t, S s)) {}
\ No newline at end of file
