Validate options given to schema fields (#3750)

Adds a compile time validation that asserts that non-parameterized types don't have options that are not used. Useful to avoid typos having runtime implications.

Author: v0idpwn

lib/ecto/schema.ex

@@ -486,6 +486,24 @@ defmodule Ecto.Schema do
     end
   end
 
+  @field_opts [
+    :default,
+    :source,
+    :autogenerate,
+    :read_after_writes, 
+    :virtual, 
+    :primary_key,
+    :load_in_query,
+    :redact,
+    :foreign_key,
+    :on_replace, 
+    :defaults,
+    :type,
+    :where,
+    :references,
+    :skip_default_validation
+  ]
+
   @doc """
   Defines an embedded schema with the given field definitions.
 
@@ -1883,12 +1901,10 @@ defmodule Ecto.Schema do
 
   @doc false
   def __field__(mod, name, type, opts) do
-    if type == :any and !opts[:virtual] do
-      raise ArgumentError, "only virtual fields can have type :any, " <>
-                           "invalid type for field #{inspect name}"
-    end
-
     type = check_field_type!(mod, name, type, opts)
+
+    opts = Keyword.put(opts, :type, type)
+    check_options!(opts, @field_opts, "field/3")
     Module.put_attribute(mod, :changeset_fields, {name, type})
     validate_default!(type, opts[:default], opts[:skip_default_validation])
     define_field(mod, name, type, opts)
@@ -2161,15 +2177,27 @@ defmodule Ecto.Schema do
   end
 
   defp check_options!(opts, valid, fun_arity) do
-    type = Keyword.get(opts, :type)
+    case opts[:type] do
+      {:parameterized, _, _} ->
+        :ok
 
-    if is_atom(type) and Code.ensure_compiled(type) == {:module, type} and function_exported?(type, :type, 1) do
-      :ok
-    else
-      case Enum.find(opts, fn {k, _} -> not(k in valid) end) do
-        {k, _} -> raise ArgumentError, "invalid option #{inspect k} for #{fun_arity}"
-        nil -> :ok
-      end
+      {_, {:parameterized, _, _}} ->
+        :ok
+
+      :any ->
+        if !opts[:virtual], do:
+          raise ArgumentError, "only virtual fields can have type :any, " <>
+                               "invalid type for field #{inspect opts[:name]}"
+
+      type ->
+        if is_atom(type) and Code.ensure_compiled(type) == {:module, type} and function_exported?(type, :type, 1) do
+          :ok
+        else
+          case Enum.find(opts, fn {k, _} -> not(k in valid) end) do
+            {k, _} -> raise ArgumentError, "invalid option #{inspect k} for #{fun_arity}"
+            nil -> :ok
+          end
+        end
     end
   end
 

test/ecto/schema_test.exs

@@ -8,7 +8,7 @@ defmodule Ecto.SchemaTest do
 
     schema "my schema" do
       field :name,  :string, default: "eric", autogenerate: {String, :upcase, ["eric"]}
-      field :email, :string, uniq: true, read_after_writes: true
+      field :email, :string, read_after_writes: true
       field :password, :string, redact: true
       field :temp,  :any, default: "temp", virtual: true, redact: true
       field :count, :decimal, read_after_writes: true, source: :cnt
@@ -429,6 +429,28 @@ defmodule Ecto.SchemaTest do
     end
   end
 
+  test "invalid option for field" do
+    assert_raise ArgumentError, ~s/invalid option :starts_on for field\/3/, fn ->
+      defmodule SchemaInvalidFieldOption do
+        use Ecto.Schema
+
+        schema "invalid_option" do
+          field :count, :integer, starts_on: 3
+        end
+      end
+    end
+
+    # doesn't validate for parameterized types
+    defmodule SchemaInvalidOptionParameterized do
+      use Ecto.Schema
+
+      schema "invalid_option_parameterized" do
+        field :my_enum, Ecto.Enum, values: [:a, :b], random_option: 3
+        field :my_enums, Ecto.Enum, values: [:a, :b], random_option: 3
+      end
+    end
+  end
+
   test "invalid field type" do
     assert_raise ArgumentError, "invalid or unknown type {:apa} for field :name", fn ->
       defmodule SchemaInvalidFieldType do