diff --git a/src/EsopeImporter-Tests/FamixEsopeResolverTest.class.st b/src/EsopeImporter-Tests/FamixEsopeResolverTest.class.st
index bf8387a..b7b9961 100644
--- a/src/EsopeImporter-Tests/FamixEsopeResolverTest.class.st
+++ b/src/EsopeImporter-Tests/FamixEsopeResolverTest.class.st
@@ -6,7 +6,7 @@ Class {
 		'resolver',
 		'famixProgFile'
 	],
-	#category : #'EsopeImporter-Tests-Resolver'
+	#category : #'EsopeImporter-Tests-Importer'
 }
 
 { #category : #'default values' }
@@ -51,8 +51,8 @@ FamixEsopeResolverTest >> defaultAttribute: varName withType: typeName [
 { #category : #'default values' }
 FamixEsopeResolverTest >> defaultFunction: name [
 
-	^ (self newNamedEntity: name toFamix: FamixF77PUFunction) 
-		  programFile: famixProgFile
+	^ (self newEntity: FamixF77PUFunction named: name) programFile:
+		  famixProgFile
 ]
 
 { #category : #'default values' }
@@ -101,20 +101,20 @@ FamixEsopeResolverTest >> defaultInvocation: name [
 { #category : #'default values' }
 FamixEsopeResolverTest >> defaultMain: name [
 
-	^ (self newNamedEntity: name toFamix: FamixF77PUMain) 
-		  programFile: famixProgFile
+	^ (self newEntity: FamixF77PUMain named: name) programFile:
+		  famixProgFile
 ]
 
 { #category : #'default values' }
 FamixEsopeResolverTest >> defaultParameter: name [
 
-	^ self newNamedEntity: name toFamix: FamixF77Parameter
+	^ self newEntity: FamixF77Parameter named: name
 ]
 
 { #category : #'default values' }
 FamixEsopeResolverTest >> defaultProgramFile: aFilename [
 
-	^ (self newNamedEntity: aFilename toFamix: FamixF77ProgramFile)
+	^ (self newEntity: FamixF77ProgramFile named: aFilename)
 		  filename: aFilename;
 		  yourself
 ]
@@ -122,7 +122,7 @@ FamixEsopeResolverTest >> defaultProgramFile: aFilename [
 { #category : #'default values' }
 FamixEsopeResolverTest >> defaultProgramUnit: name forType: aFamixClass belongsTo: aFamixProgramFile [
 
-	^ (self newNamedEntity: name toFamix: aFamixClass) programFile:
+	^ (self newEntity: aFamixClass named: name) programFile:
 		  aFamixProgramFile
 ]
 
@@ -140,15 +140,15 @@ FamixEsopeResolverTest >> defaultSegment: segmentName with: dictDeclarations [
 { #category : #'default values' }
 FamixEsopeResolverTest >> defaultSubroutine: name [
 
-	^ (self newNamedEntity: name toFamix: FamixF77PUSubroutine) 
-		  programFile: famixProgFile
+	^ (self newEntity: FamixF77PUSubroutine named: name) programFile:
+		  famixProgFile
 ]
 
 { #category : #'default values' }
 FamixEsopeResolverTest >> defaultSubroutine: name belongsTo: aFamixProgramFile [
 
-	^ (self newNamedEntity: name toFamix: FamixF77PUSubroutine) 
-		  programFile: aFamixProgramFile
+	^ (self newEntity: FamixF77PUSubroutine named: name) programFile:
+		  aFamixProgramFile
 ]
 
 { #category : #'default values' }
@@ -163,14 +163,14 @@ FamixEsopeResolverTest >> defaultType: anIntrinsicFortranType [
 { #category : #'default values' }
 FamixEsopeResolverTest >> defaultVariable: name withType: type [
 
-	^ (self newNamedEntity: name toFamix: FamixF77Variable) 
-		  declaredType: (self defaultType: type)
+	^ (self newEntity: FamixF77Variable named: name) declaredType:
+		  (self defaultType: type)
 ]
 
-{ #category : #tests }
+{ #category : #'default values' }
 FamixEsopeResolverTest >> externalDeclaration: name [
 
-	^self newNamedEntity: name toFamix: FamixF77ExternalDeclaration
+	^ self newEntity: FamixF77ExternalDeclaration named: name
 ]
 
 { #category : #'default values' }
@@ -201,7 +201,7 @@ FamixEsopeResolverTest >> newEntity: aFamixClass [
 ]
 
 { #category : #running }
-FamixEsopeResolverTest >> newNamedEntity: aName toFamix: aFamixClass [
+FamixEsopeResolverTest >> newEntity: aFamixClass named: aName [
 
 	^ (self newEntity: aFamixClass)
 		name: aName
@@ -209,9 +209,10 @@ FamixEsopeResolverTest >> newNamedEntity: aName toFamix: aFamixClass [
 
 { #category : #running }
 FamixEsopeResolverTest >> newPU: aName [
-	^(self newNamedEntity: aName toFamix: FamixF77PUSubroutine)
-		programFile: famixProgFile ;
-		yourself
+
+	^ (self newEntity: FamixF77PUSubroutine named: aName)
+		  programFile: famixProgFile;
+		  yourself
 ]
 
 { #category : #running }
@@ -224,6 +225,43 @@ FamixEsopeResolverTest >> setUp [
 	famixProgFile  := self defaultProgramFile: './main.f'.
 ]
 
+{ #category : #tests }
+FamixEsopeResolverTest >> testMergeVariableInto [
+	"We have 2 variables with the same name one should be merged into the other which keeps its
+	 declared type and	gets the accesses of the 1st"
+
+	| variable1 variable2 sub1 sub2 |
+
+	sub1 := self defaultSubroutine: 'sub1'.
+	sub2 := self defaultSubroutine: 'sub2'.
+
+	variable1 := (self defaultVariable: 'var1' withType: 'INTEGER')
+		parentBehaviouralEntity: sub1.
+	variable2 := (self defaultVariable: 'var1' withType: 'REAL')
+		parentBehaviouralEntity: sub2.
+
+	resolver model newAccess
+		accessor: sub1 ;
+		variable: variable1.
+	resolver model newAccess
+		accessor: sub2 ;
+		variable: variable2.
+
+	self assert: variable1 incomingAccesses size equals: 1.
+	self assert: sub1 localVariables size equals: 1.
+	self assert: variable2 incomingAccesses size equals: 1.
+	self assert: sub2 localVariables size equals: 1.
+
+	resolver mergeVariable: variable2 into: variable1.
+
+	self assert: variable1 incomingAccesses size equals: 2.
+	self assert: sub1 localVariables size equals: 1.
+	self assert: variable2 incomingAccesses size equals: 0.
+	self assert: sub2 localVariables size equals: 0.
+
+	self assert: variable1 declaredType name equals: 'INTEGER'
+]
+
 { #category : #'test - implicit' }
 FamixEsopeResolverTest >> testRegisterImplicitDefault [
 
@@ -238,11 +276,11 @@ FamixEsopeResolverTest >> testRegisterImplicitDefault [
 
 	resolver registerImplicitsForPU: pu.
 
-	self assert: pu dicImplicit size equals: 26.
+	self assert: pu implicitDictionary size equals: 26.
 	
 	"testing a few of them"
-	self assert: (pu dicImplicit at: $a) equals: 'real'.
-	self assert: (pu dicImplicit at: $i) equals: 'integer'.
+	self assert: (pu implicitDictionary at: $a) equals: 'real'.
+	self assert: (pu implicitDictionary at: $i) equals: 'integer'.
 ]
 
 { #category : #'test - implicit' }
@@ -265,13 +303,13 @@ FamixEsopeResolverTest >> testRegisterImplicitMultiple [
 
 	resolver registerImplicitsForPU: pu.
 
-	self assert: pu dicImplicit size equals: 26.
+	self assert: pu implicitDictionary size equals: 26.
 
-	self assert: (pu dicImplicit at: $a) equals: 'integer'.
-	self assert: (pu dicImplicit at: $b) equals: 'real'.
-	self assert: (pu dicImplicit at: $c) equals: 'integer'.
-	self assert: (pu dicImplicit at: $d) equals: 'integer'.
-	self assert: (pu dicImplicit at: $e) equals: 'real'
+	self assert: (pu implicitDictionary at: $a) equals: 'integer'.
+	self assert: (pu implicitDictionary at: $b) equals: 'real'.
+	self assert: (pu implicitDictionary at: $c) equals: 'integer'.
+	self assert: (pu implicitDictionary at: $d) equals: 'integer'.
+	self assert: (pu implicitDictionary at: $e) equals: 'real'
 ]
 
 { #category : #'test - implicit' }
@@ -291,7 +329,7 @@ FamixEsopeResolverTest >> testRegisterImplicitNone [
 
 	resolver registerImplicitsForPU: pu.
 
-	self assert: pu dicImplicit isEmpty
+	self assert: pu implicitDictionary isEmpty
 ]
 
 { #category : #'test - implicit' }
@@ -311,12 +349,12 @@ FamixEsopeResolverTest >> testRegisterImplicitRange [
 
 	resolver registerImplicitsForPU: pu.
 
-	self assert: pu dicImplicit size equals: 26.
+	self assert: pu implicitDictionary size equals: 26.
 
-	self assert: (pu dicImplicit at: $a) equals: 'integer'.
-	self assert: (pu dicImplicit at: $b) equals: 'integer'.
-	self assert: (pu dicImplicit at: $c) equals: 'integer'.
-	self assert: (pu dicImplicit at: $d) equals: 'real'
+	self assert: (pu implicitDictionary at: $a) equals: 'integer'.
+	self assert: (pu implicitDictionary at: $b) equals: 'integer'.
+	self assert: (pu implicitDictionary at: $c) equals: 'integer'.
+	self assert: (pu implicitDictionary at: $d) equals: 'real'
 ]
 
 { #category : #'test - implicit' }
@@ -336,38 +374,14 @@ FamixEsopeResolverTest >> testRegisterImplicitSimple [
 
 	resolver registerImplicitsForPU: pu.
 
-	self assert: pu dicImplicit size equals: 26.
+	self assert: pu implicitDictionary size equals: 26.
 
-	self assert: (pu dicImplicit at: $a) equals: 'integer'.
-	self assert: (pu dicImplicit at: $b) equals: 'real'
+	self assert: (pu implicitDictionary at: $a) equals: 'integer'.
+	self assert: (pu implicitDictionary at: $b) equals: 'real'
 ]
 
 { #category : #tests }
-FamixEsopeResolverTest >> testRequalifyParameterNoVariableDeclaration [
-
-	"
-      subroutine sub(var)
-      end
-	"
-
-	| sub entity |
-
-	sub := (self newPU: 'sub')
-		addParameter: (self defaultParameter: 'var') ;
-		yourself.
-
- 	resolver resolve.
-
-	self assert: sub parameters size equals: 1.
-	entity := sub parameters anyOne.
-	self assert: entity declaredType class equals: FamixF77TypeIntrinsic.
-	self assert: entity declaredType name equals: 'real'.
-
-
-]
-
-{ #category : #tests }
-FamixEsopeResolverTest >> testRequalifyVariableDeclarationAsFunction [
+FamixEsopeResolverTest >> testRequalifyFunctionDeclarations [
 
 	"
       subroutine sub
@@ -378,14 +392,12 @@ FamixEsopeResolverTest >> testRequalifyVariableDeclarationAsFunction [
 
 	| sub |
 
-	self flag: #FIXED. "see issue #32"
-
 	sub := (self defaultSubroutine: 'sub')
 		addExternalDeclaration: (self externalDeclaration: 'fct') ;
 		addLocalVariable: (self defaultVariable: 'fct' withType: #integer) ;
 		yourself.
 
- 	resolver resolve.
+ 	resolver requalifyFunctionDeclarations.
 
 	self assert: sub localVariables isEmpty.
 	self assert: (resolver model allWithType: FamixF77Variable) isEmpty.
@@ -396,7 +408,7 @@ FamixEsopeResolverTest >> testRequalifyVariableDeclarationAsFunction [
 ]
 
 { #category : #tests }
-FamixEsopeResolverTest >> testRequalifyVariableDeclarationAsParameter [
+FamixEsopeResolverTest >> testRequalifyParameterDeclarations [
 
 	"
       subroutine sub(var)
@@ -411,7 +423,7 @@ FamixEsopeResolverTest >> testRequalifyVariableDeclarationAsParameter [
 		addLocalVariable: (self defaultVariable: 'var' withType: #integer) ;
 		yourself.
 
- 	resolver resolve.
+ 	resolver requalifyParameterDeclarations.
 
 	self assert: sub localVariables isEmpty.
 	self assert: (resolver model allWithType: FamixF77Variable) isEmpty.
@@ -424,184 +436,177 @@ FamixEsopeResolverTest >> testRequalifyVariableDeclarationAsParameter [
 
 ]
 
-{ #category : #'test-todo' }
-FamixEsopeResolverTest >> testResolveAccessAttributeDeclaredPointer [
-
-	| main access access2 varP typePoint |
-	"
-      subroutine demo
-      segment point
-        integer x
-      end segment
-	   pointeur p.point
-      p.x
-      end
+{ #category : #'test - resolveAccess' }
+FamixEsopeResolverTest >> testResolveAccesses [
+	"program main
+	 integer var
+	 var
+	 end
 	"
 
-	typePoint := self newNamedEntity: 'point' toFamix: FamixEsopeSegment.
-	typePoint addAttribute: (self newNamedEntity: 'x' toFamix: FamixFortranAttribute).
+	| main access  |
 
-	varP := self newNamedEntity: 'p' toFamix: FamixF77Variable.
-	varP declaredType: typePoint.
-	
-	access := self newEntity: FamixF77Access.
-	access attributeAt: #entity put: (self defaultIASTVarAccess: 'p').
+	main := (self defaultMain: 'main')
+		addLocalVariable: (self defaultVariable: 'var' withType: #integer);
+		addAccess: (self defaultAccess: 'var');
+		yourself.
 
-	access2 := self newEntity: FamixF77Access.
-	access2 attributeAt: #entity put: (self defaultIASTVarAccess: 'x').
+ 	resolver resolveAccesses.
 
-	access attributeAt: #attributeAccess put: access2.
-	access2 attributeAt: #parentAccess put: access.
+	self assert: main accesses size equals: 1.
+	access := main accesses first.
+
+	self assert: access variable equals: main localVariables first.
+]
+
+{ #category : #'test - resolveAccess' }
+FamixEsopeResolverTest >> testResolveAccessesForALocalVariableImplicit [
+	"program main
+	 var
+	 end
+	"
+
+	| main access  var |
 
 	main := (self defaultMain: 'main')
-		addType: typePoint ;
-		addLocalVariable: varP ;
-		accesses: {access . access2} ;
+		addAccess: (self defaultAccess: 'var');
 		yourself.
 
-	self assert: main localVariables size equals: 1.
+	self assert: main localVariables size equals: 0.
 
-	resolver resolve.
+ 	resolver resolveAccesses.
 
-	self assert: main accesses size equals: 2.
+	self assert: main localVariables size equals: 1.
+	var := main localVariables anyOne.
+	self assert: var name equals: 'var'.
+	self assert: var declaredType class equals: FamixF77TypeIntrinsic.
+	self assert: var declaredType name equals: 'real'.
 
-	self assert: access variable equals: varP.
-	self assert: access accessor equals: main.
+	self assert: main accesses size equals: 1.
 
-	self assert: access2 variable class equals: FamixFortranAttribute.
-	self assert: access2 variable parentType equals: typePoint.
-	self assert: access2 accessor equals: main.
+	access := main accesses anyOne.
+	self assert: access variable equals: var.
+	self assert: access accessor equals: main.
 
 ]
 
-{ #category : #'test-todo' }
-FamixEsopeResolverTest >> testResolveAccessAttributeNoPointer [
+{ #category : #'test - resolveAccess' }
+FamixEsopeResolverTest >> testResolveAccessesForAParameter [
 
-	| subrtn access type |
+	| subrtn access |
 	"
-      subroutine demo
-      segment point
+      subroutine demo(x)
         integer x
-      end segment
       x
       end
 	"
-
-	type := self newNamedEntity: 'point' toFamix: FamixEsopeSegment.
-	type attributes: {
-		(self newNamedEntity: 'x' toFamix: FamixFortranAttribute) }.
-
 	access := self newEntity: FamixF77Access.
 	access attributeAt: #entity put: (self defaultIASTVarAccess: 'x').
-	
+
 	subrtn := (self defaultSubroutine: 'demo')
-		addType: type ;
-		addAccess: access ;
-		yourself.
+		          addParameter:
+			          (self newEntity: FamixF77Parameter named: 'x');
+		          addAccess: access;
+		          yourself.
 
-	resolver resolve.
+	resolver resolveAccesses.
 
 	self assert: subrtn accesses size equals: 1.
 
-	self assert: access variable class equals: FamixFortranAttribute.
-	self assert: access variable parentType equals: type.
-	self assert: access accessor equals: subrtn.
-
-]
-
-{ #category : #'test-todo' }
-FamixEsopeResolverTest >> testResolveAccessDeclaredLocalVariable [
-	"program main
-	 integer var
-	 var
-	 end
-	"
-
-	| main access  |
-
-	main := (self defaultMain: 'main')
-		addLocalVariable: (self defaultVariable: 'var' withType: #integer);
-		addAccess: (self defaultAccess: 'var');
-		yourself.
-
- 	resolver resolve.
-
-	self assert: main accesses size equals: 1.
-	access := main accesses first.
-
-	self assert: access variable equals: main localVariables first.
+	self assert: access variable class equals: FamixF77Parameter.
+	self assert: access accessor equals: subrtn
 ]
 
-{ #category : #'test-todo' }
-FamixEsopeResolverTest >> testResolveAccessDeclaredPointerVariable [
+{ #category : #'test - resolveAccess' }
+FamixEsopeResolverTest >> testResolveAccessesForAPointerDotAttribute [
 
-	| main access var |
+	| main access access2 varP typePoint |
 	"
       subroutine demo
       segment point
+        integer x
       end segment
 	   pointeur p.point
-      p
+      p.x
       end
 	"
-	var := self newNamedEntity: 'p' toFamix: FamixF77Variable.
-	var declaredType: (self newNamedEntity: 'point' toFamix: FamixF77Type).
-	
+	typePoint := self newEntity: FamixEsopeSegment named: 'point'.
+	typePoint addAttribute:
+		(self newEntity: FamixFortranAttribute named: 'x').
+
+	varP := self newEntity: FamixF77Variable named: 'p'.
+	varP declaredType: typePoint.
+
+	access := self newEntity: FamixF77Access.
+	access attributeAt: #entity put: (self defaultIASTVarAccess: 'p').
+
+	access2 := self newEntity: FamixF77Access.
+	access2 attributeAt: #entity put: (self defaultIASTVarAccess: 'x').
+
+	access attributeAt: #attributeAccess put: access2.
+	access2 attributeAt: #parentAccess put: access.
+
 	main := (self defaultMain: 'main')
-		addType: (self newNamedEntity: 'point' toFamix: FamixEsopeSegment) ;
-		addLocalVariable: var ;
-		addAccess: ((self newEntity: FamixF77Access)
-			attributeAt: #entity put: (self defaultIASTVarAccess: 'p') ;
-			yourself);
-		yourself.
+		        addType: typePoint;
+		        addLocalVariable: varP;
+		        accesses: {
+				        access.
+				        access2 };
+		        yourself.
 
 	self assert: main localVariables size equals: 1.
 
-	resolver resolve.
+	resolver resolveAccesses.
 
-	var := main localVariables anyOne.
-
-	self assert: main accesses size equals: 1.
+	self assert: main accesses size equals: 2.
 
-	access := main accesses anyOne.
-	self assert: access variable equals: var.
+	self assert: access variable equals: varP.
 	self assert: access accessor equals: main.
 
+	self assert: access2 variable class equals: FamixFortranAttribute.
+	self assert: access2 variable parentType equals: typePoint.
+	self assert: access2 accessor equals: main
 ]
 
-{ #category : #'test-todo' }
-FamixEsopeResolverTest >> testResolveAccessImplicitLocalVariable [
-	"program main
-	 var
-	 end
-	"
+{ #category : #'test - resolveAccess' }
+FamixEsopeResolverTest >> testResolveAccessesForAPointerVariableDeclared [
 
-	| main access  var |
+	| main access var |
+	"
+      subroutine demo
+      segment point
+      end segment
+	   pointeur p.point
+      p
+      end
+	"
+	var := self newEntity: FamixF77Variable named: 'p'.
+	var declaredType: (self newEntity: FamixF77Type named: 'point').
 
 	main := (self defaultMain: 'main')
-		addAccess: (self defaultAccess: 'var');
-		yourself.
+		        addType: (self newEntity: FamixEsopeSegment named: 'point');
+		        addLocalVariable: var;
+		        addAccess: ((self newEntity: FamixF77Access)
+				         attributeAt: #entity
+				         put: (self defaultIASTVarAccess: 'p');
+				         yourself);
+		        yourself.
 
-	self assert: main localVariables size equals: 0.
+	self assert: main localVariables size equals: 1.
 
- 	resolver resolve.
+	resolver resolveAccesses.
 
-	self assert: main localVariables size equals: 1.
 	var := main localVariables anyOne.
-	self assert: var name equals: 'var'.
-	self assert: var declaredType class equals: FamixF77TypeIntrinsic.
-	self assert: var declaredType name equals: 'real'.
 
 	self assert: main accesses size equals: 1.
 
 	access := main accesses anyOne.
 	self assert: access variable equals: var.
-	self assert: access accessor equals: main.
-
+	self assert: access accessor equals: main
 ]
 
-{ #category : #'test-todo' }
-FamixEsopeResolverTest >> testResolveAccessImplicitPointerVariable [
+{ #category : #'test - resolveAccess' }
+FamixEsopeResolverTest >> testResolveAccessesForAPointerVariableImplicit [
 
 	| subrtn access var |
 	"
@@ -611,17 +616,18 @@ FamixEsopeResolverTest >> testResolveAccessImplicitPointerVariable [
       point
       end
 	"
-
 	subrtn := (self defaultSubroutine: 'demo')
-		addType: ((self newNamedEntity: 'point' toFamix: FamixEsopeSegment)) ;
-		addAccess: ((self newEntity: FamixF77Access)
-					     attributeAt: #entity put: (self defaultIASTVarAccess: 'point') ;
-					     yourself);
-		yourself.
+		          addType:
+			          (self newEntity: FamixEsopeSegment named: 'point');
+		          addAccess: ((self newEntity: FamixF77Access)
+				           attributeAt: #entity
+				           put: (self defaultIASTVarAccess: 'point');
+				           yourself);
+		          yourself.
 
 	self assert: subrtn localVariables size equals: 0.
 
-	resolver resolve.
+	resolver resolveAccesses.
 
 	self assert: subrtn localVariables size equals: 1.
 	var := subrtn localVariables anyOne.
@@ -633,40 +639,44 @@ FamixEsopeResolverTest >> testResolveAccessImplicitPointerVariable [
 
 	access := subrtn accesses anyOne.
 	self assert: access variable equals: var.
-	self assert: access accessor equals: subrtn.
-
+	self assert: access accessor equals: subrtn
 ]
 
-{ #category : #'test-todo' }
-FamixEsopeResolverTest >> testResolveAccessToParameter [
+{ #category : #'test - resolveAccess' }
+FamixEsopeResolverTest >> testResolveAccessesforAnAttribute [
 
-	| subrtn access |
+	| subrtn access type |
 	"
-      subroutine demo(x)
+      subroutine demo
+      segment point
         integer x
+      end segment
       x
       end
 	"
+	type := self newEntity: FamixEsopeSegment named: 'point'.
+	type attributes:
+		{ (self newEntity: FamixFortranAttribute named: 'x') }.
 
 	access := self newEntity: FamixF77Access.
 	access attributeAt: #entity put: (self defaultIASTVarAccess: 'x').
-	
+
 	subrtn := (self defaultSubroutine: 'demo')
-		addParameter: (self newNamedEntity: 'x' toFamix: FamixF77Parameter) ;
-		addAccess: access ;
-		yourself.
+		          addType: type;
+		          addAccess: access;
+		          yourself.
 
-	resolver resolve.
+	resolver resolveAccesses.
 
 	self assert: subrtn accesses size equals: 1.
 
-	self assert: access variable class equals: FamixF77Parameter.
-	self assert: access accessor equals: subrtn.
-
+	self assert: access variable class equals: FamixFortranAttribute.
+	self assert: access variable parentType equals: type.
+	self assert: access accessor equals: subrtn
 ]
 
 { #category : #tests }
-FamixEsopeResolverTest >> testResolveEsopeVariables [
+FamixEsopeResolverTest >> testResolveDeclaredTypeOfPointers [
 
 	| sub entity type var |
 	"
@@ -676,19 +686,19 @@ FamixEsopeResolverTest >> testResolveEsopeVariables [
       pointeur p.point
       end
 	"
-	type := self newNamedEntity: 'point' toFamix: FamixEsopeSegment.
-	type attributes: #(  ).
+	type := self newEntity: FamixEsopeSegment named: 'point'.
+	type attributes: #().
 
-	var := self newNamedEntity: 'p' toFamix: FamixF77Variable.
+	var := self newEntity: FamixF77Variable named: 'p'.
 	var segment: 'point'.
 	var isEsope: true.
 
 	sub := (self newPU: 'demo')
-		       addType: type;
-		       addLocalVariable: var;
-		       yourself.
+		addType: type;
+		addLocalVariable: var;
+		yourself.
 
-	resolver resolve.
+	resolver resolveDeclaredTypeOfPointers.
 
 	self assert: sub localVariables size equals: 1.
 
@@ -696,49 +706,6 @@ FamixEsopeResolverTest >> testResolveEsopeVariables [
 	self assert: entity declaredType equals: type
 ]
 
-{ #category : #tests }
-FamixEsopeResolverTest >> testResolveFunctionImplicit [
-	"
-      function fct()
-      implicit charcater(f)
-      end
-	"
-
-	| sub |
-
-	sub := (self defaultFunction: 'fct')
-		       attributeAt: #implicits
-		       put: { (self implicitRule: 'character' range: #( #( $f ) )) };
-		       yourself.
-
-	resolver resolve.
-
-	self assert: sub declaredType class equals: FamixF77TypeIntrinsic.
-	self assert: sub declaredType name equals: 'character'
-]
-
-{ #category : #tests }
-FamixEsopeResolverTest >> testResolveFunctionImplicitWrongParameters [
-	"
-      function fct()
-      implicit character(f)
-      end
-	"
-
-	| sub |
-
-	sub := self defaultFunction: 'fct'.
-	sub addParameter: (self defaultParameter: 'param').
-	sub
-		attributeAt: #implicits
-		put: { (self implicitRule: 'character' range: #( #( $f ) )) }.
-
-	resolver resolve.
-
-	self assert: sub declaredType class equals: FamixF77TypeIntrinsic.
-	self assert: sub declaredType name equals: 'character'
-]
-
 { #category : #'test - implicit' }
 FamixEsopeResolverTest >> testResolveImplicitParameter [
 
@@ -813,9 +780,124 @@ FamixEsopeResolverTest >> testResolveImplicitParameterRange [
 	self assert: entity declaredType name equals: 'character'
 ]
 
-{ #category : #'test-todo' }
-FamixEsopeResolverTest >> testResolveIncludeDirective [
+{ #category : #tests }
+FamixEsopeResolverTest >> testResolveImplicits [
 
+	"
+      subroutine sub(var)
+      end
+	"
+
+	| sub entity |
+
+	sub := (self newPU: 'sub')
+		addParameter: (self defaultParameter: 'var') ;
+		yourself.
+
+ 	resolver resolveImplicits.
+
+	self assert: sub parameters size equals: 1.
+	entity := sub parameters anyOne.
+	self assert: entity declaredType class equals: FamixF77TypeIntrinsic.
+	self assert: entity declaredType name equals: 'real'.
+
+
+]
+
+{ #category : #tests }
+FamixEsopeResolverTest >> testResolveImplicitsDeclared [
+
+	"
+      subroutine sub(var)
+      implicit character(v) 
+      end
+	"
+
+	| sub entity |
+
+	sub := (self newPU: 'sub')
+		addParameter: (self defaultParameter: 'var') ;
+		attributeAt: #implicits put: { (self implicitRule: 'character' range: #( 'v' ) ) };
+		yourself.
+
+	resolver registerImplicitsDeclarations.
+ 	resolver resolveImplicits.
+
+	self assert: sub parameters size equals: 1.
+	entity := sub parameters anyOne.
+	self assert: entity declaredType class equals: FamixF77TypeIntrinsic.
+	self assert: entity declaredType name equals: 'character'.
+
+
+]
+
+{ #category : #tests }
+FamixEsopeResolverTest >> testResolveImplicitsForFunction [
+	"
+      function fct()
+      end
+	"
+
+	| fct |
+
+	fct := self defaultFunction: 'fct'.
+
+	resolver registerImplicitsDeclarations.
+	resolver resolveImplicits.
+
+	self assert: fct declaredType class equals: FamixF77TypeIntrinsic.
+	self assert: fct declaredType name equals: 'real'
+]
+
+{ #category : #tests }
+FamixEsopeResolverTest >> testResolveImplicitsForStatementFunction [
+	"
+      function fct()
+      implicit character(f)
+      end
+	"
+
+	| fct |
+
+	fct := self newEntity: FamixF77StatementFunction named: 'f'.
+	(self defaultFunction: 'fct')
+		addStatementFunction: fct.
+
+	resolver registerImplicitsDeclarations.
+	resolver resolveImplicits.
+
+	self assert: fct declaredType class equals: FamixF77TypeIntrinsic.
+	self assert: fct declaredType name equals: 'real'
+]
+
+{ #category : #tests }
+FamixEsopeResolverTest >> testResolveImplicitsNone [
+
+	"
+      subroutine sub(var)
+		implicit none
+      end
+	"
+
+	| sub entity |
+
+	sub := (self newPU: 'sub')
+		addParameter: (self defaultParameter: 'var') ;
+		attributeAt: #implicits put: { self implicitRule: nil range: nil };
+		yourself.
+
+	resolver registerImplicitsDeclarations.
+ 	resolver resolveImplicits.
+
+	self assert: sub parameters size equals: 1.
+	entity := sub parameters anyOne.
+	self assert: entity declaredType class equals: FamixF77TypeUnknown.
+
+
+]
+
+{ #category : #tests }
+FamixEsopeResolverTest >> testResolveIncludeDirective [
 	"
 +------ point.seg ----------------------------------+
 |      subroutine @point_seg@                       |
@@ -834,29 +916,31 @@ FamixEsopeResolverTest >> testResolveIncludeDirective [
 	includedFile := self defaultProgramFile: 'point.seg.f'.
 	mainFile := self defaultProgramFile: 'main.f'.
 
-	sub := (self newNamedEntity: '@point_seg@' toFamix: FamixF77IncludedFile)
-		programFile: includedFile ;
-		types: { self newNamedEntity: 'point' toFamix: FamixEsopeSegment } ;
-		yourself.
+	sub := (self newEntity: FamixF77IncludedFile named: '@point_seg@')
+		       programFile: includedFile;
+		       types: { (self newEntity: FamixEsopeSegment named: 'point') };
+		       yourself.
 
-	main := (self newNamedEntity: 'main' toFamix: FamixF77PUMain)
-		programFile: mainFile ;
-		includes: { (self newEntity: FamixF77Include) filename: 'point.seg' } ;
-		yourself.
+	main := (self newEntity: FamixF77PUMain named: 'main')
+		        programFile: mainFile;
+		        includes:
+			        { ((self newEntity: FamixF77Include) filename: 'point.seg') };
+		        yourself.
 
 	resolver resolve.
 
-	self assert: (resolver model allWithType: FamixF77IncludedFile) size equals: 1.
-	self assert: (resolver model allWithType: FamixF77IncludedFile) first equals: sub.
-
-	self assert: main includes size equals: 1.
 	self
-		assert: main includes anyOne included
+		assert: (resolver model allWithType: FamixF77IncludedFile) size
+		equals: 1.
+	self
+		assert: (resolver model allWithType: FamixF77IncludedFile) first
 		equals: sub.
 
-	self assert: sub inclusions size equals: 1.
-	self assert: sub inclusions anyOne includedBy equals: main.
+	self assert: main includes size equals: 1.
+	self assert: main includes anyOne included equals: sub.
 
+	self assert: sub inclusions size equals: 1.
+	self assert: sub inclusions anyOne includedBy equals: main
 ]
 
 { #category : #tests }
diff --git a/src/EsopeImporter-Tests/FortranProjectImporterFileManagementTest.class.st b/src/EsopeImporter-Tests/FortranProjectImporterFileManagementTest.class.st
new file mode 100644
index 0000000..7fd013d
--- /dev/null
+++ b/src/EsopeImporter-Tests/FortranProjectImporterFileManagementTest.class.st
@@ -0,0 +1,341 @@
+"
+I am a test class for testing the management of files and paths in FortranProjectImporter
+"
+Class {
+	#name : #FortranProjectImporterFileManagementTest,
+	#superclass : #TestCase,
+	#instVars : [
+		'importer',
+		'fileSystem'
+	],
+	#category : #'EsopeImporter-Tests-Importer'
+}
+
+{ #category : #running }
+FortranProjectImporterFileManagementTest >> prepareWorkspace [
+
+	| f1 f2 |
+	fileSystem createDirectory: '/project'.
+	fileSystem createDirectory: '/project/inc1'.
+	fileSystem createDirectory: '/project/inc2'.
+	fileSystem createDirectory: '/project/src'.
+
+	(fileSystem / '/project/inc1/f1.inc') createFile.
+	(fileSystem / '/project/inc1/f2.seg') createFile.
+	(fileSystem / '/project/inc2/f3.obj') createFile.
+	"note: duplicated name f1.inc, by default importer will take the first found"
+	(fileSystem / '/project/inc2/f1.inc') createFile.
+	(fileSystem / '/project/inc2/f4.h') createFile.
+
+	f1 := (fileSystem / 'project/src/f1.fc') createFile.
+	f2 := (fileSystem / 'project/src/f2.ec') createFile.
+	(fileSystem / 'project/src/f3.f') createFile.
+
+	f1 writeStreamDo: [ :st |
+		st
+			<< '#include "f1.inc"'; cr;
+			<< '#include "f3.obj"'; cr
+	].
+
+	f2 writeStreamDo: [ :st |
+		st
+			<< '#include "f2.seg"'; cr;
+			<< '#include "f1.inc"'; cr
+	].
+
+	importer srcFolders: { fileSystem / 'project/src' }.
+	importer includeFolders: { 
+		fileSystem / 'project/inc1'.
+		fileSystem / 'project/inc2' 
+	}
+]
+
+{ #category : #running }
+FortranProjectImporterFileManagementTest >> setUp [
+	super setUp.
+
+	importer := FortranProjectImporter new.
+	importer errorHandler: FortranErrorManager new.
+	fileSystem := FileSystem memory
+
+]
+
+{ #category : #running }
+FortranProjectImporterFileManagementTest >> tearDown [ 
+
+	| folder |
+	super tearDown.
+
+	folder := './tmpEsopeImport' asFileReference.
+	folder exists ifTrue: [ folder deleteAll ].
+
+	folder := './tmpFortranImport' asFileReference.
+	folder exists ifTrue: [ folder deleteAll ]
+]
+
+{ #category : #tests }
+FortranProjectImporterFileManagementTest >> testCollectFilesInWithExtensions [
+
+	| files |
+	self prepareWorkspace.
+
+	files := importer
+		collectFilesIn: importer includeFolders first "project/inc1"
+		withExtensions: {'inc'}.
+	self assert: files size equals: 1.
+	self assert: files anyOne fullName equals: '/project/inc1/f1.inc'.
+]
+
+{ #category : #tests }
+FortranProjectImporterFileManagementTest >> testCollectFilesInWithExtensionsSeveralFiles [
+
+	| files |
+	self prepareWorkspace.
+
+	files := importer
+		collectFilesIn: importer includeFolders anyOne parent "/project/"
+		withExtensions: {'inc'}.
+	self assert: files size equals: 2.
+	self assert: files anyOne basename equals: 'f1.inc'.
+]
+
+{ #category : #tests }
+FortranProjectImporterFileManagementTest >> testCollectIncludedFileNames [
+
+	self prepareWorkspace.
+
+	self
+		assertCollection: importer collectIncludedFileNames
+		hasSameElements: #( 'f1.inc' 'f2.seg' 'f3.obj' )
+]
+
+{ #category : #tests }
+FortranProjectImporterFileManagementTest >> testCollectSrcFilesWithExtensions [
+	| files |
+	self prepareWorkspace.
+
+	files := importer collectSrcFilesWithExtensions: {'fc' . 'ec' }.
+	self
+		assertCollection: (files collect: #basename)
+		 hasSameElements: #( 'f1.fc' 'f2.ec' )
+]
+
+{ #category : #tests }
+FortranProjectImporterFileManagementTest >> testEsopeFileToFortran [
+
+	| srcFile destFile |
+	srcFile := fileSystem / 'esope.e'.
+	srcFile writeStreamDo: [ :st |
+		st << '      subroutine rtn
+      segini p
+      end
+' ].
+	destFile := fileSystem / 'esope.f'.
+
+	importer deEsopify: srcFile from: fileSystem root to: fileSystem root.
+
+	self assert: destFile exists.
+	self
+		assert: destFile contents withInternalLineEndings
+		equals: '      subroutine rtn
+c@_   segini p
+      end
+'
+]
+
+{ #category : #'tests - import steps' }
+FortranProjectImporterFileManagementTest >> testEsopeToFortran [
+
+	| tempFolder |
+	self prepareWorkspace.
+
+	importer esopeToFortran.
+
+	tempFolder := './tmpFortranImport' asFileReference.
+	self assert: tempFolder exists.
+	self assert: tempFolder children size equals: 1.
+	self assert: tempFolder children anyOne basename equals: 'project'.
+
+	tempFolder := tempFolder / 'project'.
+	self assert: tempFolder children size equals: 1.
+	self assert: tempFolder children anyOne basename equals: 'src'.
+
+	tempFolder := tempFolder / 'src'.
+	self
+		assertCollection: (tempFolder children collect: #basename)
+		hasSameElements: #( 'f1.f' 'f2.f' ).
+
+]
+
+{ #category : #tests }
+FortranProjectImporterFileManagementTest >> testFakeEsopeProgramUnitTo [
+
+	| srcFile resultFile |
+	(fileSystem  / 'inc') createDirectory.
+	srcFile := (fileSystem / 'inc' / 'included.h').
+	srcFile writeStreamDo: [:st | st << 'a line' ; cr].
+
+	importer fakeEsopeProgramUnit: srcFile to: (fileSystem / 'tmpEsope').
+
+	resultFile := fileSystem / 'tmpEsope' / 'inc' / 'included.h.E'.
+
+	self assert: resultFile exists.
+	self assert: resultFile contents equals: '      subroutine _$included_h
+a line
+      end
+'
+]
+
+{ #category : #tests }
+FortranProjectImporterFileManagementTest >> testFileReferencesForIn [
+
+	| files |
+	self prepareWorkspace.
+
+	files := importer findFiles: #( 'f2.seg' ) in: { importer includeFolders first }.
+
+	self assert: files size equals: 1.
+	self assert: files anyOne fullName equals: '/project/inc1/f2.seg'
+]
+
+{ #category : #tests }
+FortranProjectImporterFileManagementTest >> testFileReferencesForInNotFound [
+
+	| files |
+	self prepareWorkspace.
+
+	files := importer findFiles: #( 'inexistent.file' ) in: importer includeFolders.
+
+	self assert: files size equals: 0
+]
+
+{ #category : #tests }
+FortranProjectImporterFileManagementTest >> testFileReferencesForInWithDuplicate [
+
+	| files |
+	self prepareWorkspace.
+
+
+	files := importer findFiles: #( 'f1.inc' ) in: importer includeFolders.
+
+	self assert: files size equals: 1.
+	self assert: files anyOne fullName equals: '/project/inc1/f1.inc'
+]
+
+{ #category : #tests }
+FortranProjectImporterFileManagementTest >> testFindIncludesIn [
+	| includer files |
+	self prepareWorkspace.
+
+	includer := importer srcFolders anyOne children detect: [ :file | file basename = 'f1.fc' ].
+	files := importer includedNamesIn: includer.
+
+	self
+		assertCollection: files
+		 hasSameElements: #( 'f1.inc' 'f3.obj' )
+]
+
+{ #category : #tests }
+FortranProjectImporterFileManagementTest >> testFolderContainingAmong [
+
+	| file |
+	file := (fileSystem / 'included.h') createFile.
+
+	self assert: (importer folderContaining: 'included.h' among: { fileSystem } ) equals: file
+]
+
+{ #category : #tests }
+FortranProjectImporterFileManagementTest >> testFolderContainingAmongNoExtension [
+
+	| file |
+	file := (fileSystem / 'included') createFile.
+
+	self assert: (importer folderContaining: 'included' among: { fileSystem } ) equals: file
+]
+
+{ #category : #tests }
+FortranProjectImporterFileManagementTest >> testFolderContainingAmongNotFound [
+
+	(fileSystem / 'excluded.h') createFile.
+
+	self assert: (importer folderContaining: 'included.h' among: { fileSystem } ) equals: nil
+]
+
+{ #category : #tests }
+FortranProjectImporterFileManagementTest >> testFolderContainingAmongWithPath [
+
+	| file |
+	(fileSystem  / 'inc') createDirectory.
+	file := (fileSystem / 'inc' / 'included.h') createFile.
+
+	self assert: (importer folderContaining: 'inc/included.h' among: { fileSystem } ) equals: file
+]
+
+{ #category : #'tests - import steps' }
+FortranProjectImporterFileManagementTest >> testFortranToJsonAST [
+
+	| tempFolder |
+	self skip: 'Depends on having a parser available, but parsers are external to Pharo so, would fail on CI'.
+
+	self prepareWorkspace.
+
+	importer fortranToJsonAST.
+
+	tempFolder := './tmpJsonImport' asFileReference.
+	self assert: tempFolder exists.
+	self assert: tempFolder children size equals: 1.
+	self assert: tempFolder children anyOne basename equals: 'project'.
+
+	tempFolder := tempFolder / 'project'.
+	self assert: tempFolder children size equals: 1.
+	self assert: tempFolder children anyOne basename equals: 'src'.
+
+	tempFolder := tempFolder / 'src'.
+	self
+		assertCollection: (tempFolder children collect: #basename)
+		hasSameElements: #( 'f3.json' ).
+
+]
+
+{ #category : #tests }
+FortranProjectImporterFileManagementTest >> testGetIncludedFile [
+
+	self assert: (importer getIncludedFileName: '#include  "blah.inc"') equals: 'blah.inc'
+]
+
+{ #category : #'tests - import steps' }
+FortranProjectImporterFileManagementTest >> testIncludedFilesToEsope [
+
+	| tempFolder |
+	self prepareWorkspace.
+
+	importer includedFilesToEsope.
+
+	tempFolder := './tmpEsopeImport' asFileReference.
+	self assert: tempFolder exists.
+	self assert: tempFolder children size equals: 1.
+	self assert: tempFolder children anyOne basename equals: 'project'.
+
+	tempFolder := tempFolder / 'project'.
+	self
+		assertCollection: (tempFolder children collect: #basename)
+		hasSameElements: #( 'inc1' 'inc2' ).
+
+	self
+		assertCollection: ((tempFolder / 'inc1') children collect: #basename)
+		hasSameElements: #( 'f1.inc.E' 'f2.seg.E' ).
+
+	self
+		assertCollection: ((tempFolder / 'inc2') children collect: #basename)
+		hasSameElements: #( 'f3.obj.E').
+
+]
+
+{ #category : #tests }
+FortranProjectImporterFileManagementTest >> testUnquoteIncludedFile [
+
+	self assert: (importer unquoteIncludedFile: 'blah') equals: 'blah'.
+	self assert: (importer unquoteIncludedFile: 'blah.f') equals: 'blah.f'.
+	self assert: (importer unquoteIncludedFile: '"blah.inc"') equals: 'blah.inc'.
+	self assert: (importer unquoteIncludedFile: '<lib/blah.h>') equals: 'lib/blah.h'
+]
diff --git a/src/EsopeImporter-Tests/FortranProjectImporterTest.class.st b/src/EsopeImporter-Tests/FortranProjectImporterTest.class.st
index a2244eb..7e33daf 100644
--- a/src/EsopeImporter-Tests/FortranProjectImporterTest.class.st
+++ b/src/EsopeImporter-Tests/FortranProjectImporterTest.class.st
@@ -1,342 +1,55 @@
-"
-A FortranProjectImporterTest is a test class for testing the behavior of FortranProjectImporter
-"
 Class {
 	#name : #FortranProjectImporterTest,
 	#superclass : #TestCase,
 	#instVars : [
-		'importer',
-		'fileSystem'
+		'importer'
 	],
 	#category : #'EsopeImporter-Tests-Importer'
 }
 
-{ #category : #running }
-FortranProjectImporterTest >> prepareWorkspace [
-
-	| f1 f2 |
-	fileSystem createDirectory: '/project'.
-	fileSystem createDirectory: '/project/inc1'.
-	fileSystem createDirectory: '/project/inc2'.
-	fileSystem createDirectory: '/project/src'.
-
-	(fileSystem / '/project/inc1/f1.inc') createFile.
-	(fileSystem / '/project/inc1/f2.seg') createFile.
-	(fileSystem / '/project/inc2/f3.obj') createFile.
-	"note: duplicated name f1.inc, by default importer will take the first found"
-	(fileSystem / '/project/inc2/f1.inc') createFile.
-	(fileSystem / '/project/inc2/f4.h') createFile.
-
-	f1 := (fileSystem / 'project/src/f1.fc') createFile.
-	f2 := (fileSystem / 'project/src/f2.ec') createFile.
-	(fileSystem / 'project/src/f3.f') createFile.
-
-	f1 writeStreamDo: [ :st |
-		st
-			<< '#include "f1.inc"'; cr;
-			<< '#include "f3.obj"'; cr
-	].
-
-	f2 writeStreamDo: [ :st |
-		st
-			<< '#include "f2.seg"'; cr;
-			<< '#include "f1.inc"'; cr
-	].
-
-	importer srcFolders: { fileSystem / 'project/src' }.
-	importer includeFolders: { 
-		fileSystem / 'project/inc1'.
-		fileSystem / 'project/inc2' 
-	}
-]
-
 { #category : #running }
 FortranProjectImporterTest >> setUp [
 	super setUp.
 
 	importer := FortranProjectImporter new.
+	importer stopOnError: true.
 	importer errorHandler: FortranErrorManager new.
-	fileSystem := FileSystem memory
-
-]
-
-{ #category : #running }
-FortranProjectImporterTest >> tearDown [ 
-
-	| folder |
-	super tearDown.
-
-	folder := './tmpEsopeImport' asFileReference.
-	folder exists ifTrue: [ folder deleteAll ].
-
-	folder := './tmpFortranImport' asFileReference.
-	folder exists ifTrue: [ folder deleteAll ]
-]
-
-{ #category : #tests }
-FortranProjectImporterTest >> testCollectFilesInWithExtensions [
-
-	| files |
-	self prepareWorkspace.
-
-	files := importer
-		collectFilesIn: importer includeFolders first "project/inc1"
-		withExtensions: {'inc'}.
-	self assert: files size equals: 1.
-	self assert: files anyOne fullName equals: '/project/inc1/f1.inc'.
-]
-
-{ #category : #tests }
-FortranProjectImporterTest >> testCollectFilesInWithExtensionsSeveralFiles [
-
-	| files |
-	self prepareWorkspace.
-
-	files := importer
-		collectFilesIn: importer includeFolders anyOne parent "/project/"
-		withExtensions: {'inc'}.
-	self assert: files size equals: 2.
-	self assert: files anyOne basename equals: 'f1.inc'.
-]
-
-{ #category : #tests }
-FortranProjectImporterTest >> testCollectIncludedFileNames [
-
-	self prepareWorkspace.
-
-	self
-		assertCollection: importer collectIncludedFileNames
-		hasSameElements: #( 'f1.inc' 'f2.seg' 'f3.obj' )
-]
-
-{ #category : #tests }
-FortranProjectImporterTest >> testCollectSrcFilesWithExtensions [
-	| files |
-	self prepareWorkspace.
-
-	files := importer collectSrcFilesWithExtensions: {'fc' . 'ec' }.
-	self
-		assertCollection: (files collect: #basename)
-		 hasSameElements: #( 'f1.fc' 'f2.ec' )
-]
-
-{ #category : #tests }
-FortranProjectImporterTest >> testEsopeFileToFortran [
-
-	| srcFile destFile |
-	srcFile := fileSystem / 'esope.e'.
-	srcFile writeStreamDo: [ :st |
-		st << '      subroutine rtn
-      segini p
-      end
-' ].
-	destFile := fileSystem / 'esope.f'.
-
-	importer deEsopify: srcFile from: fileSystem root to: fileSystem root.
-
-	self assert: destFile exists.
-	self
-		assert: destFile contents withInternalLineEndings
-		equals: '      subroutine rtn
-c@_   segini p
-      end
-'
-]
-
-{ #category : #'tests - import steps' }
-FortranProjectImporterTest >> testEsopeToFortran [
-
-	| tempFolder |
-	self prepareWorkspace.
-
-	importer esopeToFortran.
-
-	tempFolder := './tmpFortranImport' asFileReference.
-	self assert: tempFolder exists.
-	self assert: tempFolder children size equals: 1.
-	self assert: tempFolder children anyOne basename equals: 'project'.
-
-	tempFolder := tempFolder / 'project'.
-	self assert: tempFolder children size equals: 1.
-	self assert: tempFolder children anyOne basename equals: 'src'.
-
-	tempFolder := tempFolder / 'src'.
-	self
-		assertCollection: (tempFolder children collect: #basename)
-		hasSameElements: #( 'f1.f' 'f2.f' ).
-
-]
-
-{ #category : #tests }
-FortranProjectImporterTest >> testFakeEsopeProgramUnitTo [
-
-	| srcFile resultFile |
-	(fileSystem  / 'inc') createDirectory.
-	srcFile := (fileSystem / 'inc' / 'included.h').
-	srcFile writeStreamDo: [:st | st << 'a line' ; cr].
-
-	importer fakeEsopeProgramUnit: srcFile to: (fileSystem / 'tmpEsope').
-
-	resultFile := fileSystem / 'tmpEsope' / 'inc' / 'included.h.E'.
-
-	self assert: resultFile exists.
-	self assert: resultFile contents equals: '      subroutine _$included_h
-a line
-      end
-'
-]
+	importer	famixModel: FamixEsopeModel new.
 
-{ #category : #tests }
-FortranProjectImporterTest >> testFileReferencesForIn [
-
-	| files |
-	self prepareWorkspace.
-
-	files := importer findFiles: #( 'f2.seg' ) in: { importer includeFolders first }.
-
-	self assert: files size equals: 1.
-	self assert: files anyOne fullName equals: '/project/inc1/f2.seg'
 ]
 
 { #category : #tests }
-FortranProjectImporterTest >> testFileReferencesForInNotFound [
+FortranProjectImporterTest >> testMakePointerFromVariable [
+	"We have a pointer variable and a normal variable with the same name
+	 the 2nd should be merged into the 1st which keeps its declared type and
+	 gets the accesses of the 2nd"
 
-	| files |
-	self prepareWorkspace.
+	| subroutine variable pointer esopeCommand |
 
-	files := importer findFiles: #( 'inexistent.file' ) in: importer includeFolders.
-
-	self assert: files size equals: 0
-]
-
-{ #category : #tests }
-FortranProjectImporterTest >> testFileReferencesForInWithDuplicate [
+	subroutine := importer famixModel newPUSubroutine name: 'sub'.
 
-	| files |
-	self prepareWorkspace.
+	variable := importer famixModel newVariable
+		name: 'pointerForASegment' ;
+		declaredType: FamixF77TypeIntrinsic new ;
+		parentBehaviouralEntity: subroutine.
+	pointer  := importer famixModel newVariable
+		name: 'pointerForASegment' ;
+		declaredType: FamixEsopeSegment new ;
+		parentBehaviouralEntity: subroutine.
 
+	importer famixModel newAccess
+		accessor: subroutine ;
+		variable: variable.
+	esopeCommand := importer famixModel newCommand
+		accessor: subroutine ;
+		variable: pointer.
 
-	files := importer findFiles: #( 'f1.inc' ) in: importer includeFolders.
-
-	self assert: files size equals: 1.
-	self assert: files anyOne fullName equals: '/project/inc1/f1.inc'
-]
-
-{ #category : #tests }
-FortranProjectImporterTest >> testFindIncludesIn [
-	| includer files |
-	self prepareWorkspace.
-
-	includer := importer srcFolders anyOne children detect: [ :file | file basename = 'f1.fc' ].
-	files := importer includedNamesIn: includer.
-
-	self
-		assertCollection: files
-		 hasSameElements: #( 'f1.inc' 'f3.obj' )
-]
+	self assert: subroutine accesses size equals: 2.
+	self assert: subroutine localVariables size equals: 2.
 
-{ #category : #tests }
-FortranProjectImporterTest >> testFolderContainingAmong [
-
-	| file |
-	file := (fileSystem / 'included.h') createFile.
-
-	self assert: (importer folderContaining: 'included.h' among: { fileSystem } ) equals: file
-]
-
-{ #category : #tests }
-FortranProjectImporterTest >> testFolderContainingAmongNoExtension [
-
-	| file |
-	file := (fileSystem / 'included') createFile.
-
-	self assert: (importer folderContaining: 'included' among: { fileSystem } ) equals: file
-]
-
-{ #category : #tests }
-FortranProjectImporterTest >> testFolderContainingAmongNotFound [
-
-	(fileSystem / 'excluded.h') createFile.
-
-	self assert: (importer folderContaining: 'included.h' among: { fileSystem } ) equals: nil
-]
-
-{ #category : #tests }
-FortranProjectImporterTest >> testFolderContainingAmongWithPath [
-
-	| file |
-	(fileSystem  / 'inc') createDirectory.
-	file := (fileSystem / 'inc' / 'included.h') createFile.
-
-	self assert: (importer folderContaining: 'inc/included.h' among: { fileSystem } ) equals: file
-]
-
-{ #category : #'tests - import steps' }
-FortranProjectImporterTest >> testFortranToJsonAST [
-
-	"This test depends on having a parser available.
-	 But parsers are external to Pharo so, would fail on CI"
-
-	"| tempFolder |
-	self prepareWorkspace.
-
-	importer fortranToJsonAST.
-
-	tempFolder := './tmpJsonImport' asFileReference.
-	self assert: tempFolder exists.
-	self assert: tempFolder children size equals: 1.
-	self assert: tempFolder children anyOne basename equals: 'project'.
-
-	tempFolder := tempFolder / 'project'.
-	self assert: tempFolder children size equals: 1.
-	self assert: tempFolder children anyOne basename equals: 'src'.
-
-	tempFolder := tempFolder / 'src'.
-	self
-		assertCollection: (tempFolder children collect: #basename)
-		hasSameElements: #( 'f3.json' ).
-"
-]
-
-{ #category : #tests }
-FortranProjectImporterTest >> testGetIncludedFile [
-
-	self assert: (importer getIncludedFileName: '#include  "blah.inc"') equals: 'blah.inc'
-]
-
-{ #category : #'tests - import steps' }
-FortranProjectImporterTest >> testIncludedFilesToEsope [
-
-	| tempFolder |
-	self prepareWorkspace.
-
-	importer includedFilesToEsope.
-
-	tempFolder := './tmpEsopeImport' asFileReference.
-	self assert: tempFolder exists.
-	self assert: tempFolder children size equals: 1.
-	self assert: tempFolder children anyOne basename equals: 'project'.
-
-	tempFolder := tempFolder / 'project'.
-	self
-		assertCollection: (tempFolder children collect: #basename)
-		hasSameElements: #( 'inc1' 'inc2' ).
-
-	self
-		assertCollection: ((tempFolder / 'inc1') children collect: #basename)
-		hasSameElements: #( 'f1.inc.E' 'f2.seg.E' ).
-
-	self
-		assertCollection: ((tempFolder / 'inc2') children collect: #basename)
-		hasSameElements: #( 'f3.obj.E').
-
-]
-
-{ #category : #tests }
-FortranProjectImporterTest >> testUnquoteIncludedFile [
+	importer newResolver.
+	importer makePointerFromVariable: esopeCommand.
 
-	self assert: (importer unquoteIncludedFile: 'blah') equals: 'blah'.
-	self assert: (importer unquoteIncludedFile: 'blah.f') equals: 'blah.f'.
-	self assert: (importer unquoteIncludedFile: '"blah.inc"') equals: 'blah.inc'.
-	self assert: (importer unquoteIncludedFile: '<lib/blah.h>') equals: 'lib/blah.h'
+	self assert: subroutine accesses size equals: 2.
+	self assert: subroutine localVariables size equals: 1.
 ]
diff --git a/src/EsopeImporter/FamixEsopeResolver.class.st b/src/EsopeImporter/FamixEsopeResolver.class.st
index 86b669a..7bfd6d5 100644
--- a/src/EsopeImporter/FamixEsopeResolver.class.st
+++ b/src/EsopeImporter/FamixEsopeResolver.class.st
@@ -8,7 +8,7 @@ Class {
 		'model',
 		'errorHandler'
 	],
-	#category : #'EsopeImporter-Resolver'
+	#category : #'EsopeImporter-Importer'
 }
 
 { #category : #'private-helper' }
@@ -19,6 +19,21 @@ FamixEsopeResolver class >> on: aMooseModel [
 		  yourself
 ]
 
+{ #category : #'symbols resolution' }
+FamixEsopeResolver >> createImplicitVariable: variableName in: anAccessor [
+	"if we are here, we know that the variable was not declared locally
+	 so we create it"
+
+	| implicitVariable |
+	implicitVariable := self newEntity: FamixF77Variable.
+	implicitVariable name: variableName.
+	implicitVariable parentBehaviouralEntity: anAccessor.
+	implicitVariable declaredType: (self resolveImplicitVariableType: implicitVariable).
+
+	^implicitVariable
+
+]
+
 { #category : #accessing }
 FamixEsopeResolver >> errorHandler [
 
@@ -32,18 +47,40 @@ FamixEsopeResolver >> errorHandler: anErrorHandler [
 ]
 
 { #category : #'private - utility' }
-FamixEsopeResolver >> findEntity: entityName inList: famixEntities [
+FamixEsopeResolver >> implicitTypeFor: name inProgramUnit: programUnit [
+	"find a type according to the first letter of the variable's name"
 
-	^ famixEntities
-		  detect: [ :entity | entity name = entityName ]
-		  ifNone: [ nil ]
+	^ programUnit implicitDictionary at: name first ifAbsent: [ FamixF77TypeUnknown defaultName ]
 ]
 
-{ #category : #'private - utility' }
-FamixEsopeResolver >> implicitTypeFor: name inProgramUnit: programUnit [
-	"find a type according to the first letter of the variable's name"
+{ #category : #'private - import' }
+FamixEsopeResolver >> mergeVariable: variableToRemove into: variableToKeep [
+	"merge meaningfull properties from variableToRemove into variableToKeep
+	 then remove links between variableToRemove and other entities (associations are
+	 bi-directional, so we actually remove variableToRemove from the other entities),
+	 finally remove variableToRemove from model
 
-	^ programUnit dicImplicit at: name first ifAbsent: [ FamixF77TypeUnknown defaultName ]
+	 properties of FamixF77Varibale are:
+	 - mooseName :						ignore, should be the same (ignoring upper/lower case)
+	 - cache :							ignore, should be empty
+	 - entityAttributes :				ignore, should be empty
+	 - mooseModel :						ignore, should be the same
+	 - isEsope :							ignore, keep value of variable1
+	 - parentBehaviouralEntity :	ignore, should be the same (clear it in variableToRemove)
+	 - incomingAccesses :				merge
+	 - name :								ignore, should be the same
+	 - isStub :							ignore
+	 - sourceAnchor :					merge, keep the first one (clear it in variableToRemove)
+	 - declaredType :					ignore, keep value of variableToKeep (clear it in variableToRemove)"
+
+	variableToRemove incomingAccesses do: [ :access |
+		access variable: variableToKeep ].
+
+	variableToRemove parentBehaviouralEntity: nil.
+	variableToRemove sourceAnchor: nil.
+	variableToRemove declaredType: nil.
+
+	model removeEntity: variableToRemove
 ]
 
 { #category : #accessing }
@@ -67,21 +104,28 @@ FamixEsopeResolver >> newEntity: aFamixClass [
 
 { #category : #'symbols resolution' }
 FamixEsopeResolver >> registerImplicitForPU: programUnit range: aRange forType: iASTTypeRef [
+	"for letters in aRange register in implicit dictionary the corresponding iASTTypeRef"
 
 	(aRange size = 1)
-	ifTrue: [ programUnit dicImplicit at: aRange first put: iASTTypeRef entityName asSymbol ]
+	ifTrue: [ programUnit implicitDictionary
+		at: aRange first
+		put: iASTTypeRef entityName asSymbol ]
 	ifFalse: [ 
 		(aRange first to: aRange second) do: [ :letter |
-			programUnit dicImplicit at: letter put: iASTTypeRef entityName asSymbol
+			programUnit implicitDictionary 
+				at: letter
+				put: iASTTypeRef entityName asSymbol
 		]
 	]
 ]
 
-{ #category : #'symbols resolution' }
+{ #category : #run }
 FamixEsopeResolver >> registerImplicitsDeclarations [
+	"find IMPLICIT declaration statements in all program units and register them
+	 in the respective implicitDictionary"
 
 	(self model allWithSubTypesOf: FamixF77ProgramUnit) do: [ :programUnit |
-		self errorHandler enterContext: programUnit name.
+		self errorHandler enterContext: 'on file ' , programUnit name.
 		self registerImplicitsForPU: programUnit.
 		self errorHandler leaveContext
 	]
@@ -89,15 +133,20 @@ FamixEsopeResolver >> registerImplicitsDeclarations [
 
 { #category : #'symbols resolution' }
 FamixEsopeResolver >> registerImplicitsForPU: programUnit [
+	"find all IMPLICIT declaration statement in programUnit and register them
+	 in the implicitDictionary of this program-unit"
 
 	(programUnit attributeAt: #implicits ifAbsent: [ #() ])
 	do: [ :implicitDeclaration | 
 		implicitDeclaration ranges
-			ifNotNil: [ 
-				implicitDeclaration ranges do: [ :aRange | 
-					self registerImplicitForPU: programUnit range: aRange forType: implicitDeclaration forType] ]
+			ifNotNil: [ :ranges |
+				ranges do: [ :aRange | 
+					self
+						registerImplicitForPU: programUnit
+						range: aRange
+						forType: implicitDeclaration forType] ]
 			ifNil: [ "implicit none"
-				programUnit dicImplicit removeAll ]
+				programUnit implicitDictionary removeAll ]
 	]
 ]
 
@@ -121,8 +170,13 @@ FamixEsopeResolver >> removeStoredIAST: anEntity forSymbol: aSymbol [
 
 { #category : #'symbols resolution' }
 FamixEsopeResolver >> requalifyFunctionDeclaration: external [
-	"external decalration of functin followed by a VariableDeclaration of the same function
-	 we simply remove the VariableDeclaration"
+	"external declaration of function followed by a VariableDeclaration of the same function
+	 we simply remove the VariableDeclaration
+	 We remove links with other entities (associations are bi-directional, this remove the
+	 variable from the other entities):
+	 - parentBehaviouralEntity:
+	 - declaredType -- probably useless, varDeclaration should have no declaredType
+	 - incomingAccesses -- probably useless, varDeclaration should have no incomingAccesses"
 
 	external programUnit localVariables
 		detect: [ :varDeclaration |
@@ -130,6 +184,8 @@ FamixEsopeResolver >> requalifyFunctionDeclaration: external [
 		]
 		ifFound: [ :varDeclaration |
 			varDeclaration parentBehaviouralEntity: nil.
+			varDeclaration declaredType: nil.
+			varDeclaration incomingAccesses: #().
 			model remove: varDeclaration.
 		]
 ]
@@ -146,59 +202,49 @@ FamixEsopeResolver >> requalifyFunctionDeclarations [
 
 { #category : #'symbols resolution' }
 FamixEsopeResolver >> requalifyParameterDeclaration: param [
-	"looks for a VariableDeclaration in the same program unit with the same name"
-
-	
-	param parentBehaviouralEntity localVariables
-		detect: [ :varDeclaration |
-			varDeclaration name = param name
-		]
-		ifFound: [ :varDeclaration |
-			param declaredType: varDeclaration declaredType.
-			varDeclaration parentBehaviouralEntity: nil.
-			model remove: varDeclaration
+	"looks for a VariableDeclaration in the same program unit with the same name
+	 then merge the VariableDeclaration into param, but keeping the declaredType
+	 of the VariableDeclaration"
+
+	(self resolveAsLocalVariable: param name in: param parentBehaviouralEntity)
+		do: [ :varDeclaration |
+			(varDeclaration = param)
+			ifFalse: [
+				param declaredType: varDeclaration declaredType.
+				self mergeVariable: varDeclaration into: param
+			]
 		]
 ]
 
 { #category : #'symbols resolution' }
 FamixEsopeResolver >> requalifyParameterDeclarations [
-	"For each parameter, try to find a matching VariableDeclaration"
+	"For each parameter, try to find a matching VariableDeclaration to merge them together"
 
 	(model allWithType: FamixF77Parameter) do: [ :param |
 		self requalifyParameterDeclaration: param
 	]
 ]
 
-{ #category : #'symbols resolution' }
+{ #category : #run }
 FamixEsopeResolver >> requalifyVariableDeclarations [
-	"a LocalVariable declaration can be a:
-	- Function
-	- Parameter
-	- LocalVariable"
+	"some LocalVariable entities are actually Functions
+	 for some other, there is a Parameter and a LocalVariable for the same Fortran entity"
 
 	self requalifyParameterDeclarations.
 	self requalifyFunctionDeclarations.
 ]
 
-{ #category : #'symbols resolution' }
+{ #category : #run }
 FamixEsopeResolver >> resolve [
 
-	#( resolveIncludes
-		registerImplicitsDeclarations
-		requalifyVariableDeclarations
-		resolveImplicits
-		resolveEsopeVariables
-		resolveInvocations
-		resolveAccesses) do: [ :step |
+	self resolvingSteps do: [ :step |
 		self errorHandler enterContext: step.
 		self perform: step.
-		self errorHandler leaveContext
-	]
+		self errorHandler leaveContext ]
 ]
 
 { #category : #'symbols resolution' }
 FamixEsopeResolver >> resolveAccess: anAccess [
-
 	"- ignore access already resolved (may happen in case of attribute access)
 	 - try to find a matching local variable declaration (including parameters)
 	 - if not, try to resolve as an implict pointer 
@@ -207,28 +253,16 @@ FamixEsopeResolver >> resolveAccess: anAccess [
 	 
 	After that, if the variable resolved to a pointer, resolve its attribute access"
 
-	| variableAccessed |
-
-	anAccess variable ifNotNil: [ ^self ].
-	(anAccess attributeAt: #parentAccess ifAbsent: [ nil])
-		ifNotNil: [ "there is a #parentAccess" ^self ].
+	| variableName |
+	anAccess variable ifNotNil: [ ^ self ].
+	(anAccess attributeAt: #parentAccess ifAbsent: [ nil ]) ifNotNil: [ "there is a #parentAccess"
+		^ self ].
 
-	variableAccessed := self removeStoredIAST: anAccess forSymbol: #entity.
+	variableName := (self removeStoredIAST: anAccess forSymbol: #entity)
+		                entityName.
 
-	(self resolveAccess: anAccess asLocalVariable: variableAccessed)
-	ifNotNil: [ :localVar | anAccess variable: localVar ]
-	ifNil: [
-		(self resolveAccess: anAccess asImplicitPointer: variableAccessed)
-		ifNotNil: [ :pointer | anAccess variable: pointer ]
-		ifNil: [
-			(self resolveAccess: anAccess asImplicitAttribute: variableAccessed)
-			ifNotNil: [ :attribute | anAccess variable: attribute ]
-			ifNil: [
-				anAccess variable: 
-					(self resolveAccess: anAccess asImplicitVariable: variableAccessed)
-			]
-		]
-	].
+	anAccess variable:
+		(self resolveVariableNamed: variableName in: anAccess accessor).
 
 	(self removeStoredIAST: anAccess forSymbol: #attributeAccess)
 		ifNotNil: [ :attributeAccess |
@@ -236,83 +270,89 @@ FamixEsopeResolver >> resolveAccess: anAccess [
 ]
 
 { #category : #'symbols resolution' }
-FamixEsopeResolver >> resolveAccess: anAccess asImplicitAttribute: accessedVariable [
+FamixEsopeResolver >> resolveAccess: anAccess fromPointer: aPointerVariable [
 
-	^self
-		findEntity: accessedVariable entityName
-		inList: (anAccess accessor allTypes flatCollect: [ :type | type attributes ])
-]
+	| variableAccessed |
+	variableAccessed := self
+		removeStoredIAST: anAccess
+		forSymbol: #entity.
+	self assert: variableAccessed isNotNil.
 
-{ #category : #'symbols resolution' }
-FamixEsopeResolver >> resolveAccess: anAccess asImplicitPointer: variableAccessed [
-	"try to find a segment with the same name as the accessed variable"
+	aPointerVariable declaredType attributes
+		detect: [ :att | att name = variableAccessed entityName ]
+		ifFound: [ :att | anAccess variable: att ].
 
-	self flag: #FIXME. "Issue with an attribute."
+	self removeStoredIAST: anAccess forSymbol: #parentAccess
+]
 
-	^anAccess accessor allTypes
-		detect: [ :type |
-			(type class = FamixEsopeSegment) and: 
-			[ type name = variableAccessed entityName ]
-		]
-		ifOne: [ :type |
-			(self newEntity: FamixF77Variable)
-				name: variableAccessed entityName ;
-				parentBehaviouralEntity: anAccess accessor ;
-				declaredType: type ;
-				yourself
-		]
-		ifNone: [ nil ].
+{ #category : #run }
+FamixEsopeResolver >> resolveAccesses [
 
+	(self model allWithSubTypesOf: FamixF77Access) do: [ :access |
+		self resolveAccess: access ]
 ]
 
 { #category : #'symbols resolution' }
-FamixEsopeResolver >> resolveAccess: anAccess asImplicitVariable: variableAccessed [
-	"if we are here, we know that the variable was not declared locally
-	 so we create it"
+FamixEsopeResolver >> resolveAllVariablesNamed: variableName in: accessor [
 
-	| implicitVariable |
-	implicitVariable := self newEntity: FamixF77Variable.
-	implicitVariable name: variableAccessed entityName.
-	implicitVariable parentBehaviouralEntity: anAccess accessor.
-	implicitVariable declaredType: (self resolveImplicitVariableType: implicitVariable).
+	| found  |
+	found := OrderedCollection new.
 
-	^implicitVariable
+	found addAll: (self resolveAsLocalVariable: variableName in: accessor).
+	found addAll: (self resolveAsImplicitPointer: variableName in: accessor).
+	found addAll: (self resolveAsImplicitAttribute: variableName in: accessor).
 
+	^found
 ]
 
 { #category : #'symbols resolution' }
-FamixEsopeResolver >> resolveAccess: anAccess asLocalVariable: accessedVariable [
+FamixEsopeResolver >> resolveAsImplicitAttribute: variableName in: anAccessor [
 
-	^self
-		findEntity: accessedVariable entityName
-		inList: anAccess accessor allLocalVariables
+	^(anAccessor allTypes flatCollect: [ :type | type attributes ])
+		select: [ :entity | entity name = variableName ]
 ]
 
 { #category : #'symbols resolution' }
-FamixEsopeResolver >> resolveAccess: anAccess fromPointer: aPointerVariable [
-
-	| variableAccessed |
-	variableAccessed := self
-		                    removeStoredIAST: anAccess
-		                    forSymbol: #entity.
-	self assert: variableAccessed isNotNil.
+FamixEsopeResolver >> resolveAsImplicitPointer: variableName in: anAccessor [
+	"try to find a segment with the same name as the accessed variable"
 
-	aPointerVariable declaredType attributes
-		detect: [ :att | att name = variableAccessed entityName ]
-		ifFound: [ :att | anAccess variable: att ].
+	self flag: #FIXME. "Issue with an attribute."
 
-	self removeStoredIAST: anAccess forSymbol: #parentAccess
+	^anAccessor allTypes
+		select: [ :type |
+			(type class = FamixEsopeSegment) and: 
+			[ type name = variableName ]
+		]
+		thenCollect: [ :type |
+			(self newEntity: FamixF77Variable)
+				name: variableName ;
+				parentBehaviouralEntity: anAccessor ;
+				declaredType: type ;
+				yourself
+		]
 ]
 
 { #category : #'symbols resolution' }
-FamixEsopeResolver >> resolveAccesses [
+FamixEsopeResolver >> resolveAsLocalVariable: variableName in: anAccessor [
 
-	(self model allWithSubTypesOf: FamixF77Access) do: [ :access |
-		self resolveAccess: access ]
+	^anAccessor allLocalVariables
+		select: [ :entity | entity name = variableName ]
+]
+
+{ #category : #run }
+FamixEsopeResolver >> resolveDeclaredTypeOfPointers [
+	
+	self flag: #FIXME. "Some Esope variables are not labelled as such"
+	
+	(self model allWithSubTypesOf: FamixF77Variable) 
+		do: [ :var | 
+			var isEsope ifTrue: [ self resolveEsopeVariable: var ]
+		]
 ]
 
 { #category : #'symbols resolution' }
 FamixEsopeResolver >> resolveEsopeVariable: esopeVariable [
+	"sets the declaredType of declared pointer esopeVariable"
 
 	| segments |
 	segments := self model allWithType: FamixEsopeSegment.
@@ -321,16 +361,6 @@ FamixEsopeResolver >> resolveEsopeVariable: esopeVariable [
 		ifFound: [ :segment | esopeVariable declaredType: segment ]
 ]
 
-{ #category : #'symbols resolution' }
-FamixEsopeResolver >> resolveEsopeVariables [
-	self flag: #FIXME. "Some Esope variables are not labelled as such"
-	
-	(self model allWithSubTypesOf: FamixF77Variable) 
-		do: [ :var | 
-			var isEsope ifTrue: [ self resolveEsopeVariable: var ]
-		]
-]
-
 { #category : #'symbols resolution' }
 FamixEsopeResolver >> resolveImplicitFunction: function [
 
@@ -350,32 +380,39 @@ FamixEsopeResolver >> resolveImplicitVariableType: aVariable [
 
 ]
 
-{ #category : #'symbols resolution' }
+{ #category : #run }
 FamixEsopeResolver >> resolveImplicits [
+	"put a declaredType based on IMPLICIT declarations for all variables with no declaredType"
 
 	(model allWithType: FamixF77Parameter) do: [ :param |
-		param declaredType ifNil: [
-			param 	declaredType: (self resolveImplicitVariableType: param)
-		]
+		self setImplicitDeclaredType: param in: param parentBehaviouralEntity
+	].
+
+	(model allWithType: FamixF77Variable) do: [ :var |
+		self setImplicitDeclaredType: var in: var parentBehaviouralEntity
+	].
+
+	(model allWithType: FamixF77StatementFunction) do: [ :func |
+		self setImplicitDeclaredType: func in: func parentEntity
 	].
 
 	(model allWithType: FamixF77PUFunction) do: [ :func |
-		func declaredType ifNil: [
-			self resolveImplicitFunction: func
-		]
+		self setImplicitDeclaredType: func in: func
 	] 
+
 ]
 
-{ #category : #'symbols resolution' }
+{ #category : #run }
 FamixEsopeResolver >> resolveIncludes [
-	"puts FamixF77IncludedFile into the FamixF77Include that include them"
+	"links FamixF77IncludedFile with the FamixF77Include_s that concern them"
 
 	(self model allWithType: FamixF77Include) 
 	do: [ :include |
 		(self model allWithType: FamixF77IncludedFile)
-			detect: [ :includedFile | includedFile programFile filename asPath basename beginsWith: include filename ]
+			detect: [ :includedFile |
+				includedFile programFile filename asPath basename beginsWith: include filename ]
 			ifFound: [ :includedFile | include included: includedFile ]
-			ifNone: [ Notification signal: 'IncludedFile: No such file or directory' ]
+			ifNone: [ Notification signal: ' no such file' , include filename ]
 	]
 ]
 
@@ -403,7 +440,7 @@ FamixEsopeResolver >> resolveInvocation: anInvocation [
 			anInvocation addCandidate: invocatedFound ]
 ]
 
-{ #category : #'symbols resolution' }
+{ #category : #run }
 FamixEsopeResolver >> resolveInvocations [
 
 	(self model allWithType: FamixF77Invocation) do: [ :invocation |
@@ -419,3 +456,41 @@ FamixEsopeResolver >> resolveTypeName: aName [
 		detect: [ :type | type name = aName ]
 		ifNone: [ self model newTypeUnknown ]
 ]
+
+{ #category : #'symbols resolution' }
+FamixEsopeResolver >> resolveVariableNamed: variableName in: accessor [
+	| found |
+	found := self resolveAllVariablesNamed: variableName in: accessor.
+
+	(found size > 1) ifTrue: [ Exception signal: 'several variables named "', variableName , '" in "' , accessor name , '"' ].
+	(found size = 1) ifTrue: [ ^found anyOne ].
+
+	^self createImplicitVariable: variableName in: accessor
+]
+
+{ #category : #run }
+FamixEsopeResolver >> resolvingSteps [
+
+	^ #( resolveIncludes
+		  registerImplicitsDeclarations
+	     requalifyVariableDeclarations
+		  resolveImplicits
+		  #resolveDeclaredTypeOfPointers
+	     resolveInvocations
+		  resolveAccesses )
+]
+
+{ #category : #run }
+FamixEsopeResolver >> setImplicitDeclaredType: anEntity in: owner [
+	"put a declaredType to anEntity based on IMPLICIT declarations in owner
+	 Note: implicit types are intrinsic types so we could simplify the use of #resolveTypeName:
+	 (which looks in all the types)"
+
+	anEntity declaredType
+		ifNil: [
+			anEntity declaredType: 
+				(self resolveTypeName:
+					(self implicitTypeFor: anEntity name inProgramUnit: owner))
+		]
+
+]
diff --git a/src/EsopeImporter/FamixF77ProgramUnit.extension.st b/src/EsopeImporter/FamixF77ProgramUnit.extension.st
index 4d44ce1..b070998 100644
--- a/src/EsopeImporter/FamixF77ProgramUnit.extension.st
+++ b/src/EsopeImporter/FamixF77ProgramUnit.extension.st
@@ -11,9 +11,9 @@ FamixF77ProgramUnit >> defaultImplicit [
 ]
 
 { #category : #'*EsopeImporter' }
-FamixF77ProgramUnit >> dicImplicit [
+FamixF77ProgramUnit >> implicitDictionary [
 
-	^ self attributeAt: #dicImplicit ifAbsentPut: [ self defaultImplicit ]
+	^ self attributeAt: #implicitDictionary ifAbsentPut: [ self defaultImplicit ]
 ]
 
 { #category : #'*EsopeImporter' }
diff --git a/src/EsopeImporter/FamixF77StatementFunction.extension.st b/src/EsopeImporter/FamixF77StatementFunction.extension.st
index aa224e3..e47afc0 100644
--- a/src/EsopeImporter/FamixF77StatementFunction.extension.st
+++ b/src/EsopeImporter/FamixF77StatementFunction.extension.st
@@ -13,7 +13,7 @@ FamixF77StatementFunction >> allTypes [
 ]
 
 { #category : #'*EsopeImporter' }
-FamixF77StatementFunction >> dicImplicit [
+FamixF77StatementFunction >> implicitDictionary [
 
-	^parentEntity dicImplicit
+	^parentEntity implicitDictionary
 ]
diff --git a/src/EsopeImporter/FortranErrorManager.class.st b/src/EsopeImporter/FortranErrorManager.class.st
index e057100..16ad9c3 100644
--- a/src/EsopeImporter/FortranErrorManager.class.st
+++ b/src/EsopeImporter/FortranErrorManager.class.st
@@ -1,3 +1,6 @@
+"
+I register errors during the import process and allow to proceed, ignoring them
+"
 Class {
 	#name : #FortranErrorManager,
 	#superclass : #Object,
diff --git a/src/EsopeImporter/FortranImporterFileMap.class.st b/src/EsopeImporter/FortranImporterFileMap.class.st
deleted file mode 100644
index 7220301..0000000
--- a/src/EsopeImporter/FortranImporterFileMap.class.st
+++ /dev/null
@@ -1,18 +0,0 @@
-Class {
-	#name : #FortranImporterFileMap,
-	#superclass : #Object,
-	#instVars : [
-		'includedFiles',
-		'esopeFiles',
-		'fortranFiles'
-	],
-	#category : #'EsopeImporter-Importer'
-}
-
-{ #category : #initialization }
-FortranImporterFileMap >> initialize [ 
-
-	includedFiles := OrderedCollection new.
-	esopeFiles := OrderedCollection new.
-	fortranFiles := OrderedCollection new
-]
diff --git a/src/EsopeImporter/FortranImporterTempFile.class.st b/src/EsopeImporter/FortranImporterTempFile.class.st
deleted file mode 100644
index 18c596c..0000000
--- a/src/EsopeImporter/FortranImporterTempFile.class.st
+++ /dev/null
@@ -1,26 +0,0 @@
-Class {
-	#name : #FortranImporterTempFile,
-	#superclass : #FileReference,
-	#instVars : [
-		'localName'
-	],
-	#category : #'EsopeImporter-Importer'
-}
-
-{ #category : #'instance creation' }
-FortranImporterTempFile class >> from: aFileReference [
-
-	^self fileSystem: aFileReference fileSystem path: aFileReference path
-]
-
-{ #category : #accessing }
-FortranImporterTempFile >> localName [
-
-	^ localName
-]
-
-{ #category : #accessing }
-FortranImporterTempFile >> localName: anObject [
-
-	localName := anObject
-]
diff --git a/src/EsopeImporter/FortranProjectImporter.class.st b/src/EsopeImporter/FortranProjectImporter.class.st
index 2085c3b..56eb279 100644
--- a/src/EsopeImporter/FortranProjectImporter.class.st
+++ b/src/EsopeImporter/FortranProjectImporter.class.st
@@ -52,10 +52,10 @@ Class {
 		'errorHandler',
 		'stopOnError',
 		'includedFiles',
-		'tempFiles',
 		'tempEsopeFolder',
 		'tempFortranFolder',
-		'tempJsonFolder'
+		'tempJsonFolder',
+		'resolver'
 	],
 	#category : #'EsopeImporter-Importer'
 }
@@ -195,13 +195,13 @@ FortranProjectImporter >> ensureEmptyFolder: folder [
 	^folder
 ]
 
-{ #category : #accessing }
+{ #category : #'error management' }
 FortranProjectImporter >> errorHandler [
 
 	^ errorHandler
 ]
 
-{ #category : #accessing }
+{ #category : #'error management' }
 FortranProjectImporter >> errorHandler: anObject [
 
 	errorHandler := anObject
@@ -279,9 +279,9 @@ FortranProjectImporter >> famixModel: anObject [
 
 { #category : #run }
 FortranProjectImporter >> famixResolve [
+	"creates a resolver and resolve all pending names"
 
-	(FamixEsopeResolver on: famixModel)
-		errorHandler: errorHandler ;
+	self newResolver
 		resolve.
 
 ]
@@ -365,6 +365,7 @@ FortranProjectImporter >> import [
 		Warning signal: 'Set source folders first' ].
 
 	errorHandler := FortranErrorManager new.
+	errorHandler stopOnError: self stopOnError.
 
 	UIManager default displayProgress: ''
 		from: 0 to: (self importSteps size - 1)
@@ -391,7 +392,8 @@ FortranProjectImporter >> importSteps [
 
 		'JSon AST to Intermediary AST' -> #jsonASTToIAST .
 		'Intermediary AST to Famix' -> #iASTToFamix .
-		'Famix symbol resolution' -> #famixResolve
+		'Famix symbol resolution' -> #famixResolve .
+		'Pointer variables type propagation' -> #propagatePointerType .
 	}
 ]
 
@@ -437,14 +439,6 @@ FortranProjectImporter >> includedNamesIn: srcFileReference [
 
 ]
 
-{ #category : #initialization }
-FortranProjectImporter >> initialize [
-
-	super initialize.
-
-	tempFiles := FortranImporterFileMap new.
-]
-
 { #category : #'private - files' }
 FortranProjectImporter >> isIncludeLine: aString [
 
@@ -477,6 +471,29 @@ FortranProjectImporter >> jsonASTToIAST [
 
 ]
 
+{ #category : #'private - import' }
+FortranProjectImporter >> makePointerFromVariable: esopeCmd [
+	"esopeCmd is a kind of Access where the variable is an Esope pointeur
+	 We need to:
+	 - check if there is another variable with the same name in the owner
+	 - if so, merge the 2 variables into one"
+
+	(resolver
+		 resolveAllVariablesNamed: esopeCmd variable name
+		 in: esopeCmd accessor)
+
+		do: [ :variable |
+			variable = esopeCmd variable
+				ifFalse: [ resolver mergeVariable: variable into: esopeCmd variable ] ]
+]
+
+{ #category : #'private - import' }
+FortranProjectImporter >> newResolver [
+
+	^resolver := (FamixEsopeResolver  on: famixModel)
+		errorHandler: errorHandler
+]
+
 { #category : #'private - import' }
 FortranProjectImporter >> parseFortran77: localPath from: srcFolder to: destFolder [
 	"runs fortran77 parser on localPath in srcFolder to JSON file in destFolder"
@@ -506,6 +523,14 @@ FortranProjectImporter >> parseFortran77File: srcFileReference to: destFileRefer
 	)
 ]
 
+{ #category : #run }
+FortranProjectImporter >> propagatePointerType [
+
+	(famixModel allWithType: FamixEsopeCommand) do: [ :esopeCmd |
+		self makePointerFromVariable: esopeCmd
+	]
+]
+
 { #category : #accessing }
 FortranProjectImporter >> srcFolders [
 
@@ -523,6 +548,18 @@ FortranProjectImporter >> srcFolders: aCollection [
 	]
 ]
 
+{ #category : #'error management' }
+FortranProjectImporter >> stopOnError [
+
+	^ stopOnError ifNil: [ false ]
+]
+
+{ #category : #'error management' }
+FortranProjectImporter >> stopOnError: anObject [
+
+	stopOnError := anObject
+]
+
 { #category : #accessing }
 FortranProjectImporter >> tempEsopeFolder [
 
diff --git a/src/EsopeImporter/IASTAbstractFamixVisitor.class.st b/src/EsopeImporter/IASTAbstractFamixVisitor.class.st
index 9cb0401..c356c82 100644
--- a/src/EsopeImporter/IASTAbstractFamixVisitor.class.st
+++ b/src/EsopeImporter/IASTAbstractFamixVisitor.class.st
@@ -23,7 +23,7 @@ IASTAbstractFamixVisitor >> createFamixF77Access: anIastObject [
 { #category : #'private-creation' }
 IASTAbstractFamixVisitor >> createImplicitsDictionaryFor: anEntity [
 
-	anEntity attributeAt: #dicImplicit put: self defaultImplicit
+	anEntity attributeAt: #implicitDictionary put: self defaultImplicit
 ]
 
 { #category : #'private-creation' }
diff --git a/src/EsopeImporter/IASTToFamixEsopeVisitor.class.st b/src/EsopeImporter/IASTToFamixEsopeVisitor.class.st
index 9cb0eb4..90bb703 100644
--- a/src/EsopeImporter/IASTToFamixEsopeVisitor.class.st
+++ b/src/EsopeImporter/IASTToFamixEsopeVisitor.class.st
@@ -18,10 +18,7 @@ IASTToFamixEsopeVisitor >> visitIASTEsopePointer: aPointerVar [
 	| varsNames |
 	varsNames := aPointerVar entityName substrings: '.'.
 	varsNames size < 2 ifTrue: [ ^ self ].
-	"declaredType:
-			  (self
-				   newType: varsNames second
-				   sourceAnchor: aPointerVar sourceAnchor);"
+
 	^ (self model newVariableNamed: varsNames first)
 		  sourceAnchor:
 			  (self visitIndexedFileAnchor: aPointerVar sourceAnchor);
diff --git a/src/EsopeImporter/JsonToIASTVisitor.class.st b/src/EsopeImporter/JsonToIASTVisitor.class.st
index 8b52fd9..90a37b0 100644
--- a/src/EsopeImporter/JsonToIASTVisitor.class.st
+++ b/src/EsopeImporter/JsonToIASTVisitor.class.st
@@ -25,9 +25,9 @@ JsonToIASTVisitor >> createEsopeCommand: anEsopeCommentNode [
 	| data |
 	data := self processEsopeComment: anEsopeCommentNode.
 	^ IASTEsopeSegCommand new
-		  sourceAnchor: (self makeIndexedAnchor: data second);
-		  esopeCommand: data third;
-		  entityName: data fourth;
+		  sourceAnchor: (self makeIndexedAnchor: data second) ;
+		  esopeCommand: data third asLowercase ;
+		  entityName: data fourth asLowercase ;
 		  yourself
 ]
 
diff --git a/src/EsopeImporter/PPEsopeGrammar.class.st b/src/EsopeImporter/PPEsopeGrammar.class.st
index af47a2e..24c3caf 100644
--- a/src/EsopeImporter/PPEsopeGrammar.class.st
+++ b/src/EsopeImporter/PPEsopeGrammar.class.st
@@ -31,7 +31,7 @@ Class {
 		'commentLine',
 		'anyLine'
 	],
-	#category : #'EsopeImporter-Rewriter'
+	#category : #'EsopeImporter-Importer'
 }
 
 { #category : #utility }
diff --git a/src/EsopeImporter/PPEsopeRewriter.class.st b/src/EsopeImporter/PPEsopeRewriter.class.st
index 429011a..75e0907 100644
--- a/src/EsopeImporter/PPEsopeRewriter.class.st
+++ b/src/EsopeImporter/PPEsopeRewriter.class.st
@@ -1,10 +1,13 @@
+"
+I am a ""de-esopifier"", I make Fortran source code from Esope source by ""removing"" Esope specific constructs
+"
 Class {
 	#name : #PPEsopeRewriter,
 	#superclass : #PPEsopeGrammar,
 	#instVars : [
 		'stream'
 	],
-	#category : #'EsopeImporter-Rewriter'
+	#category : #'EsopeImporter-Importer'
 }
 
 { #category : #accessing }