Make implicit rule fails at first time but succeeds at second time - makefile

Question

I encounter an error relating to implicit rule in make (3.81). The example codes are:
dongli:test02 dongli$ ls -R
Makefile a.F90 b.F90 dir
./dir:
a.t.F90
The dependencies among the codes are:
a.t.F90: a.F90
a.t.o: a.t.F90
b.o: b.F90
b: a.t.o b.o
That is a.F90 is intermediate code, and a.t.F90 will be updated when a.F90 is updated. My make process is:
Test 1 (All codes on position):
-------------------------------------------------------------
Project: >>> test <<<
-------------------------------------------------------------
Creating dependency a.t.o
-------------------------------------------------------------
-----> ./dir/a.t.F90
Creating dependency b.o
-------------------------------------------------------------
-----> b.F90
Creating target 'b'
---> b is created.
-------------------------------------------------------------
Finished
-------------------------------------------------------------
Test 2 (touch a.F90):
dongli:test02 dongli$ touch a.F90
dongli:test02 dongli$ make
-------------------------------------------------------------
Project: >>> test <<<
-------------------------------------------------------------
Processing templates in a.F90
-------------------------------------------------------------
Creating dependency a.t.o
-------------------------------------------------------------
-----> a.t.F90
gfortran: error: a.t.F90: No such file or directory
gfortran: fatal error: no input files
compilation terminated.
make: *** [a.t.o] Error 1
Test 3: (Run make again):
dongli:test02 dongli$ make
-------------------------------------------------------------
Project: >>> test <<<
-------------------------------------------------------------
Creating dependency a.t.o
-------------------------------------------------------------
-----> ./dir/a.t.F90
Creating dependency b.o
-------------------------------------------------------------
-----> b.F90
Creating target 'b'
---> b is created.
-------------------------------------------------------------
Finished
-------------------------------------------------------------
I know there is a bug in make about directory caching (see here), but in my case, dir/a.t.F90 exists all the time. Any idea? Thanks!
Update1:
I use make -d to capture the following information in test 2:
Finished prerequisites of target file `a.t.F90'.
Prerequisite `a.F90' is newer than target `a.t.F90'.
Must remake target `a.t.F90'.
Ignoring VPATH name `./dir/a.t.F90'.
...
Successfully remade target file `a.t.F90'.
Finished prerequisites of target file `a.t.o'.
Prerequisite `a.t.F90' of target `a.t.o' does not exist.
Must remake target `a.t.o'.
Why ./dir/a.t.F90 is ignored when its prerequisite a.F90 is newer than it?
Update2:
I have put the example codes on gist.
Update3:
I found the following relating information:
If a target needs to be rebuilt, GNU make discards the file name found
during the VPATH search for this target, and builds the file locally
using the file name given in the makefile. If a target does not need
to be rebuilt, GNU make uses the file name found during the VPATH
search.

Answer 1

You really need to show the rules that create these targets. You've provided a lot of information about many aspects of your build, but one of the most critical aspects of debugging make issues is seeing the rules.
Failures like this (where the first build fails and the second succeeds) are almost invariably due to rules that do not behave as you have described them to make. If you tell make that a rule builds a file "foo", by creating something like foo : bar, but then the recipe that you write doesn't actually create "foo" but rather "bar/foo", something like:
foo : bar ; cp bar bar/foo
then that is wrong. Another common reason for such issues is that you define a rule that builds "foo.x", but it also builds "foo.y" and you don't tell make about it but then later use "foo.y" as a prerequisite, that can't work. You have to define a rule that tells make that both those files are generated from a single invocation of the recipe, such as:
%.x %.y : %.z ; cp $< $*.x && cp $< $*.y
And finally, you mention VPATH above and it looks like you're trying to use VPATH to find generated files. That will not work. VPATH can only be used to find source files (files make doesn't know how to build and expects to always be present). Without seeing more about your makefiles and how the rules are constructed, that's about all we can say.
Edited to add:
I'm not sure it's really necessary to use so much eval and call here; often people seem to go straight to these very powerful tools when simpler ones would suffice just as well. In any event, the problem you're having is exactly as I suspected in my first comment above; you have this rule:
%.t.F90: %.$(1)
#echo " Processing templates in $$^"
#echo $$(seperator)
#cp $$< dir/$$#
Note the last line, where instead of creating $# you're creating dir/$#; this is precisely the situation I described above. Whenever you have a rule that builds something that is not exactly $#, it's almost 100% certain that rule is wrong. You need to write this as:
dir/%.t.F90: %.$(1)
#echo " Processing templates in $$^"
#echo $$(seperator)
#cp $$< $$#
and maybe more changes to match that target.

Answer 2

I make a workaround that I inserted some scripts in the implicit rule that add the missing directory part of the code, since VPATH has some constraints on this.
%.o: %.$(1)
#echo " Creating dependency $$#"
#echo $$(seperator)
#TEMPLATE_PATTERN='.*\.t\.$(1)'; \ <
if [[ $$$$(dirname $$<) == '.' && '$$<' =~ $$$$TEMPLATE_PATTERN ]]; then \ <
SRC=$(PROJECT_ROOT)/.codemate/processed_codes/$$<; \ <
else \ <
SRC=$$<; \ <
fi; \ <
$(FC) -c $$$$SRC $(OPTIONS) $(FFLAGS) $(INCLUDES)
labeled by <.