\part{Modules de la bibliothèque standard Nit}
\chapter{Kernel}
-Le module |kernel| est à la base de toute la hiérarchie objet de Nit, c'est donc un module de base. Par exemple, il contient les classes fondamentales tel que |Bool|, |Char|, |Float|, |Int|, |Object|...
+Le module |kernel| est à la base de toute la hiérarchie objet de Nit, c'est donc un module de base. Par exemple, il contient les classes fondamentales telles que |Bool|, |Char|, |Float|, |Int|, |Object|...
Faisons un tour rapide des classes principales du module |kernel| :
\begin{description}
\item[Object]C'est la super classe implicite de toutes les classes en Nit : toutes ces méthodes sont donc héritées par toutes les classes.
\item[Bool]Représente les booléens. Les seules instances possibles de cette classe sont |true| et |false|. Les booléens sont souvent utilisés dans les branchements conditionnels et les boucles.
\item[Char]Représente les caractères.
- \item[Comparable]C'est l'ancêtre de toutes les classes qui peuvent être comparés selon un ordre total.
+ \item[Comparable]C'est l'ancêtre de toutes les classes dont les instances peuvent être comparées selon un ordre total.
\item[Discrete]L'ancêtre de toutes les classes représentant des ensembles dénombrables comme les entiers ou l'alphabet.
\item[Float]Représente les nombres à virgule flottante.
\item[Int]Représente les nombres entiers.
\end{description}
-Les classes du module |kernel| sont fréquemment raffinées dans les autres modules de la librairie standard.
+Les classes du module |kernel| sont fréquemment raffinées dans les autres modules de la bibliothèque standard.
\chapter{String}
Ce module introduit les classes permettant de manipuler les chaînes de caractères.
Le module string raffine les classes |Array|, |Collection|, |Float|, |Int|, |Map| et |Object| pour y rajouter la méthode |to_s|.
\chapter{Maths}
-Le module math raffine les classes Object, Int et Float pour y rajouter une série de méthodes en rapport avec les mathématiques. Elle est automatiquement importée avec la libraire standard.
+Le module math raffine les classes Object, Int et Float pour y rajouter une série de méthodes en rapport avec les mathématiques. Elle est automatiquement importée avec la bibliothèque standard.
\section{Variables mathématiques}
Le module math raffine la classes Object pour lui rajouter la méthode |pi| (3.141592) :
\lstinputlisting[language=Nit]{./modules/listings/pi1_c.nit}
\section{Fonctions trigonométriques}
-Les méthodes sin(), cos(), tan(), asin(), acos(), atan() permettent d'effectuer les opérations trigonométriques.Les angles doivent être exprimés en radians. Pour convertir des degrés en radian, il suffit de les multiplier par pi/180.
+Les méthodes sin(), cos(), tan(), asin(), acos(), atan() permettent d'effectuer les opérations trigonométriques. Les angles doivent être exprimés en radians. Pour convertir des degrés en radian, il suffit de les multiplier par pi/180.
Exemple :
\lstinputlisting[language=Nit]{./modules/listings/cos1_c.nit}
\section{Interfaces des collections}
\subsection{Interface Collection}
-Cette interface définit des méthodes pour des objets qui gèrent des éléments d'une façon assez générale. Elle est la super interface de plusieurs interfaces de la libraire standard. Plusieurs classes qui gèrent une collection implémentent une interface qui hérite de l'interface Collection.
+Cette interface définit des méthodes pour des objets qui gèrent des éléments d'une façon assez générale. Elle est la super interface de plusieurs interfaces de la bibliothèque standard. Plusieurs classes qui gèrent une collection implémentent une interface qui hérite de l'interface Collection.
Cette interface définit plusieurs méthodes :
\end{tabularx}
\section{Séquences}
-Les séquences sont des collections indexées et ordonnées. La notion d'index est importante, elle précise que chaque valeur est associé à une sorte d'étiquette numérique permettant de la retrouver. L'ordre de la séquence est donc induit par l'ordre des étiquettes.
+Les séquences sont des collections indexées et ordonnées. La notion d'index est importante, elle précise que chaque valeur est associée à une sorte d'étiquette numérique permettant de la retrouver. L'ordre de la séquence est donc induit par l'ordre des étiquettes.
L'interface Sequence introduit les méthodes suivantes :
\hline
first:E & Retourne le premier élément de la séquence. \\
\hline
- first=(E) & Définie le premier élément de la séquence. \\
+ first=(E) & Définit le premier élément de la séquence. \\
\hline
last:E & Retourne le dernier élément de la séquence. \\
\hline
- last=(E) & Définie le dernier élément de la séquence. \\
+ last=(E) & Définit le dernier élément de la séquence. \\
\hline
pop:E & Retourne et retire le dernier élément de la séquence. \\
\hline
\lstinputlisting[language=Nit]{./modules/listings/list1_c.nit}
\subsection{Tableaux}
-Les tableaux représentent des collections d'objets dont la taille est dynamique. Les tableaux sont gérées grâce à la classe Array.
+Les tableaux représentent des collections d'objets dont la taille est dynamique. Les tableaux sont gérés grâce à la classe Array.
-Chaque objet de type Array gère une capacité qui est le nombre total d'élément qu'il est possible d'insérer avant d'agrandir le tableau. Cette capacité a donc une relation avec le nombre d'éléments contenus dans la collection. Lors d'un ajout dans la collection, cette capacité et le nombre d'éléments de la collection déterminent si le tableau doit être agrandi. Si un nombre important d'élément doit être ajouté, il est possible de forcer l'agrandissement de cette capacité avec la méthode |enlarge|. Son usage évite une perte de temps liée au recalcul de la taille de la collection.
+Chaque objet de type Array gère une capacité qui est le nombre total d'éléments qu'il est possible d'insérer avant d'agrandir le tableau. Cette capacité a donc une relation avec le nombre d'éléments contenus dans la collection. Lors d'un ajout dans la collection, cette capacité et le nombre d'éléments de la collection déterminent si le tableau doit être agrandi. Si un nombre important d'éléments doit être ajouté, il est possible de forcer l'agrandissement de cette capacité avec la méthode |enlarge|. Son usage évite une perte de temps liée au recalcul de la taille de la collection.
Exemple :
\lstinputlisting[language=Nit]{./modules/listings/array1_c.nit}
\lstinputlisting[language=Nit]{./modules/listings/array2_c.nit}
\section{Ensembles}
-Un ensemble (Set) est une collection qui n'autorise pas l'insertion de doublons.
+Un ensemble (Set) est une collection qui n'autorise pas la présence de doublons.
-L'interface Set définit les méthodes d'une collection qui n'accepte pas de doublons dans ces éléments. Elle hérite de l'interface Collection mais elle ne définie pas de nouvelle méthode. Pour déterminer si un élément est déjà inséré dans la collection, la comparaison est basée sur les valeurs des éléments.
+L'interface Set définit les méthodes d'une collection qui n'accepte pas de doublons dans ces éléments. Elle hérite de l'interface Collection mais elle ne définit pas de nouvelle méthode. Pour déterminer si un élément est déjà présent dans la collection, la comparaison est basée sur les valeurs des éléments.
L'interface Set possède deux implémentations concrètes :
\documentclass[letterpaper,11pt]{doc_nit}
-\usepackage{../nit_version}
% Titre du document et auteur
\title{Développez en Nit}
\author{Université du Québec à Montréal}
-\date{\today\\\nitversion}
+\date{v0.5}
% Début du document
\begin{document}
\input{./licence.tex}
% Fin du document
-\end{document}
+\end{document}
\ No newline at end of file
end
class ClasseComplete
-special ClasseAbstraite
+ super ClasseAbstraite
end
var o = new ClasseComplete
end
class MonAutreClasse
-special MaClasse
+ super MaClasse
redef fun methode(i: Int): Int
do
return i
rayon = r
end
- redef fun aire: Float
+ redef fun aire: Float
do
return pi * rayon * rayon
end
end
+
+var forme: Forme
+
+forme = new Carre(10.0)
+print forme.aire # Affiche "100"
+
+forme = new Cercle(10.0)
+print forme.aire # Affiche "314.15"
\chapter{Concept de classe}\r
L'idée de base de la programmation orientée objet est de rassembler dans une même entité les données et les traitements qui s'y appliquent. Dans cette partie, nous allons voir comment Nit permet de développer en objet.\r
\r
-Une classe est le support de l'encapsulation : c'est un ensemble de données et de fonction regroupées dans une même entité. Une classe est une description abstraite d'un objet. Les fonctions qui opèrent sur les données sont appelées des méthodes. Les données en elles-mêmes sont appelées des attributs. Les attributs et les méthodes représentent les propriétés de la classe. Instancier une classe consiste à créer un objet sur son modèle.\r
+Une classe est le support de l'encapsulation : c'est un ensemble de données et de fonction regroupées dans une même entité. Une classe est une description abstraite d'un ensemble d'objet ayant des propriétés communes. Les fonctions qui opèrent sur les données sont appelées des méthodes. Les données en elles-mêmes sont appelées des attributs. Les attributs et les méthodes représentent les propriétés de la classe.\r
\r
Rappelons qu'en Nit absolument TOUT est objet.\r
\r
Pour accéder à une classe il faut en déclarer une instance ou objet.\r
\r
-Une classe se compose en deux parties : un en-tête et un corps. Le corps peut être divisé en deux sections : la déclaration de ses propriétés (attributs et la définition des méthodes. Les méthodes et les données sont pourvues d'attributs de visibilité qui gère leur accessibilité par les composants hors de la classe.\r
+Une classe se compose de deux parties : un en-tête et un corps. Le corps peut être divisé en deux sections : la déclaration de ses propriétés (attributs) et la définition des méthodes. Les méthodes et les données sont pourvues d'attributs de visibilité qui gèrent leur accessibilité par les composants hors de la classe.\r
\r
Une classe comporte donc sa déclaration, des attributs et la définition de ses méthodes.\r
\r
-En Nit, toutes les classes héritent forcément de la classe |Object|. Cette relation d'héritage est implicite, c'est à dire qu'il n'y a pas besoin de la déclarer.\r
+En Nit, toutes les classes héritent forcément de la classe |Object|. Cette relation d'héritage est implicite, c'est à dire qu'il n'est pas nécessaire de la déclarer.\r
\r
\section{Syntaxe et déclaration d'une classe}\r
La syntaxe de déclaration d'un classe est la suivante :\r
L'ordre des méthodes dans une classe n'a pas d'importance. Si dans une classe, on rencontre d'abord la méthode A puis la méthode B, B peut être appelée sans problème dans A.\r
\r
\chapter{Objets}\r
-La classe est la description d'un objet. Un objet est une instance d'une classe. Pour chaque instance d'une classe, le code est le même, seules les données (valeurs des attributs) sont différentes à chaque objet.\r
+La classe est la description d'un objet. Un objet est une instance d'une classe. Pour chaque instance d'une classe, le code est le même, seules les données (valeurs des attributs) sont différentes pour chaque objet.\r
\r
\section{Instancier une classe : créer un objet}\r
L'opérateur |new| se charge de créer une nouvelle instance d'une classe et de l'associer à une variable.\r
Cela n'est pas obligatoire grâce au typage adaptatif (voir chapitre~\ref{typage-adaptatif} \nameref{typage-adaptatif}) mais on peut aussi préciser le type sur la variable qui va recevoir l'instance :\r
\lstinputlisting[language=Nit]{./poo/listings/new2_s.nit}\r
\r
-En Nit, toutes les classes sont instanciées par allocation dynamique à part les types universels (voir chapitre~\ref{universal} \nameref{universal}). Dans l'exemple précédent, la variable |instance| contient une référence sur la classe instanciée (contient l'adresse de l'objet qu'elle désigne : attention toutefois, il n'est pas possible de manipuler ou d'effectuer des opérations directement sur cette adresse comme en C).\r
+En Nit, toutes les classes sont instanciées par allocation dynamique à part les types universels (voir chapitre~\ref{universal} \nameref{universal}). Dans l'exemple précédent, la variable |instance| contient une référence sur un objet de la classe instanciée (contient l'adresse de l'objet qu'elle désigne : attention toutefois, il n'est pas possible de manipuler ou d'effectuer des opérations directement sur cette adresse comme en C).\r
\r
\lstinputlisting[language=Nit]{./poo/listings/new3_s.nit}\r
\r
\end{description}\r
\r
\section{Références et comparaison d'objets}\r
-Les variables de type objet que l'on déclare ne contiennent pas un objet mais une référence vers cet objet. Lorsque l'on écrit |instance1 = instance2|, on copie la référence |instance1| dans |instance2| : |instance1| et |instance2| pointent sur le même objet. Par défaut, l'opérateur |==| permet de comparer ces références. Deux objets avec des propriétés identiques sont deux objets distincts.\r
+Les variables de type objet que l'on déclare ne contiennent pas un objet mais une référence vers cet objet. Lorsque l'on écrit |instance1 = instance2|, on copie la référence |instance1| dans |instance2| : |instance1| et |instance2| pointent sur le même objet. Par défaut, l'opérateur |==| est celui de la classe |Object| et permet de comparer ces références. Deux objets avec des propriétés identiques sont deux objets distincts.\r
\r
\lstinputlisting[language=Nit]{./poo/listings/comparaison1_s.nit}\r
Si on souhaite comparer deux objets en se basant sur la valeur de leurs attributs, il est possible de redéfinir l'opérateur |==| dans leur classe (voir section~\ref{redef-operateur} \nameref{redef-operateur}).\r
\r
-Par exemple, l'opérateur |==| a été redéfinit pour la classe String il est donc possible de comparer deux String en se basant sur leurs valeurs :\r
+Par exemple, l'opérateur |==| a été redéfini pour la classe String il est donc possible de comparer deux String en se basant sur leurs valeurs :\r
\lstinputlisting[language=Nit, linerange=1-5]{./poo/listings/comparaison2_c.nit}\r
\r
-Il est possible de comparer le type de deux objets, c'est à dire de vérifier si deux objets sont de la même classe ou non. Pour cela nous allons utiliser la méthode |is_same_type(o:Object)|. Cette méthode est introduite dans la classe |Object|, comme toutes les classes en héritent implicitement, elle est disponible dans toutes les classes.\r
+Il est possible de comparer le type de deux objets, c'est à dire de vérifier si deux objets sont de la même classe ou non. Pour cela il faut utiliser la méthode |is_same_type(o:Object)|. Cette méthode est introduite dans la classe |Object|, comme toutes les classes en héritent implicitement, elle est disponible dans toutes les classes.\r
\r
\lstinputlisting[language=Nit, linerange=8-9, firstnumber=last]{./poo/listings/comparaison2_c.nit}\r
\r
Pour vérifier que deux variables sont en fait des références vers le même objet, il est possible d'utiliser le mot-clé |is| :\r
-\lstinputlisting[language=Nit, linerange=6, firstnumber=last]{./poo/listings/comparaison2_c.nit}\r
+\lstinputlisting[language=Nit, linerange=6-6, firstnumber=last]{./poo/listings/comparaison2_c.nit}\r
\r
-\section{Objet null}\r
-En Nit, il existe une particularité pour l'objet |null|. Contrairement à Java il ne peut pas être utilisé à la place de n'importe où. En effet, Nit propose un mécanisme permettant de limiter statiquement les erreurs fréquentes de type |nullPointerException|.\r
+\section{Types nullable}\r
+En Nit, il existe une particularité pour la valeur |null|. Contrairement à Java il ne peut pas être utilisé n'importe où. En effet, Nit propose un mécanisme permettant de limiter statiquement les erreurs fréquentes de type |nullPointerException|.\r
\r
Pour qu'une variable puisse prendre la valeur |null|, elle doit avoir été déclarée explicitement avec le type |nullable| :\r
\lstinputlisting[language=Nit]{./poo/listings/nullable1_c.nit}\r
Dans l'exemple précédent, si on omet de préciser le type comme |nullable|, le compilateur Nit lèvera une erreur au moment de la compilation.\r
\r
+La valeur |null| peut donc être utilisée avec n'importe quel type \textit{nullable} mais aucun message ne peut être envoyé à |null|.\r
+\r
\chapter{Modificateurs d'accès}\r
-Les modificateurs d'accès assurent le contrôle des conditions d'héritage, d'accès aux éléments et de modification de données par les autres classes. Ils s'appliquent aussi bien aux classes, qu'aux méthodes et attributs.\r
+Les modificateurs d'accès assurent le contrôle des conditions d'héritage, d'accès aux éléments et de modification de données par les autres classes. Ils s'appliquent aussi bien aux classes qu'aux méthodes et attributs.\r
\r
\section{Visibilité des entités}\r
De nombreux langages orientés objet introduisent des attributs de visibilité pour réglementer l'accès aux classes et aux objets, aux méthodes et aux données.\r
\r
%TODO reformuler\r
\begin{description}\r
- \item[Par défaut : public] Il n'existe pas de mot clé pour définir ce niveau, qui est le niveau par défaut lorsqu'aucun modificateur n'est précisé. Un attribut ou une méthode déclaré public est visible par tous les autres objets. Dans la philosophie orientée objet aucun attribut ne devrait être déclaré public : il est préférable d'écrire des méthodes pour le consulter et le modifier.\r
- \item[protected] Si un attribut ou une méthode est déclarée |protected|, seules les méthodes de ses sous classes pourront y accéder.\r
+ \item[Par défaut : public] Il n'existe pas de mot clé pour définir ce niveau, qui est le niveau par défaut lorsqu'aucun modificateur n'est précisé. Un attribut ou une méthode public est visible par tous les autres objets. Dans la philosophie orientée objet, aucun attribut ne devrait être déclaré public : il est préférable d'écrire des méthodes pour le consulter et le modifier.\r
+ \item[protected] Si un attribut ou une méthode est déclaré |protected|, seules les méthodes des sous classes pourront y accéder.\r
\item[private] C'est le niveau de protection le plus fort. Les composants ne sont visibles qu'à l'intérieur du fichier où est définie la classe.\r
\end{description}\r
\r
\section{Types retournés}\r
Le type retourné correspond au type de l'objet qui est renvoyé par la méthode. Si la méthode ne retourne rien, alors on ne précise pas le type retourné.\r
\r
-La valeur de retour de la méthode doit être transmise par l'instruction |return|. Elle indique la valeur que prend la méthode et termine celle ci : toutes les instructions qui suivent |return| ne seront pas exécutées. Si des instructions sont placées après le mot clé |return|, une erreur |unreachable statement| sera levée lors de la compilation.\r
+La valeur de retour de la méthode doit être transmise par l'instruction |return|. Elle indique la valeur que prend la méthode et termine celle ci : les instructions qui suivent |return| à l'intérieur du même bloc ne seront pas exécutées. Si des instructions sont placées après le mot clé |return|, une erreur |unreachable statement| sera levée lors de la compilation.\r
\r
\lstinputlisting[language=Nit]{./poo/listings/methode1_c.nit}\r
\r
Il est possible d'inclure une instruction |return| dans une méthode sensée ne rien retourner : cela permet de quitter la méthode.\r
\r
\section{Passage de paramètres}\r
-Les paramètres des méthodes sont déclarés entre parenthèses et séparés par des virgules. Le type et le nombre de paramètres déclarés doivent correspondre au type et au nombre de paramètres transmis. Si un méthode n'accepte pas de paramètres, il suffit de ne pas indiquer de parenthèses :\r
+Les paramètres des méthodes sont déclarés entre parenthèses et séparés par des virgules. Le type et le nombre de paramètres déclarés doivent correspondre au type et au nombre de paramètres transmis. Si une méthode n'accepte pas de paramètres, il suffit de ne pas indiquer de parenthèses :\r
\lstinputlisting[language=Nit]{./poo/listings/methode2_c.nit}\r
\r
Si plusieurs paramètres ont le même type, il est possible de le factoriser :\r
\r
Il n'est pas possible d'indiquer des valeurs par défaut dans les paramètres. \r
\r
-Lorsqu'un objet est passé comme paramètre à une méthode, cette dernière reçoit une référence qui désigne son emplacement mémoire d'origine et qui est une copie de la variable. Il est possible de modifier l'objet grâce à ces méthodes mais il n'est pas possible de remplacer la référence contenue dans la variable passée en paramètre : ce changement n'aura lieu que localement à la méthode.\r
+Lorsqu'un objet est passé comme paramètre à une méthode, cette dernière reçoit une référence qui désigne son emplacement mémoire d'origine. Il est possible de modifier l'objet grâce à ces méthodes mais il n'est pas possible de remplacer la référence contenue dans la variable passée en paramètre : ce changement n'aura lieu que localement à la méthode.\r
\r
\section{Envoi de message}\r
Un message est émis lorsqu'on demande à un objet d'exécuter l'une de ses méthodes.\r
\lstinputlisting[language=Nit]{./poo/listings/methode8_c.nit}\r
\r
\section{Nombre variable de paramètres}\r
-Il est possible d'indiquer qu'une méthode peut recevoir un nombre variable de paramètre grâce à l'opérateur |...|. Le paramètre sera alors considéré comme un tableau du type spécifié. L'envoi de message pourra alors contenir aucun, un ou plusieurs arguments pour le paramètre ainsi déclaré.\r
+Il est possible d'indiquer qu'une méthode peut recevoir un nombre variable de paramètre grâce à l'opérateur |...|. Le paramètre sera alors considéré comme un tableau du type spécifié. L'envoi de message pourra alors contenir zéro, un ou plusieurs arguments pour le paramètre ainsi déclaré.\r
\r
\lstinputlisting[language=Nit]{./poo/listings/methode9_c.nit}\r
\r
-Seulement un seul paramètre variable est autorisé dans une signature.\r
+Un seul paramètre variable est autorisé dans une signature.\r
\r
\section{Enchaînement de références}\r
Il est possible d'enchaîner les envois de messages aux retours des méthodes :\r
\lstinputlisting[language=Nit]{./poo/listings/methode5_c.nit}\r
\r
-Ici on appelle la méthode to\_upper de l'objet retourné par la méthode substring de l'objet "abcd".\r
+Ici on appelle la méthode \textit{to\_upper} de l'objet retourné par la méthode \textit{substring} de l'objet \textit{"abcd"}.\r
\r
\section{Mot-clé self}\r
\r
Voici un exemple d'utilisation des getters automatiques :\r
\lstinputlisting[language=Nit]{./poo/listings/accesseurs2_c.nit}\r
\r
-Pour les setters, ils sont toujours générés comme étant |private|. Pour changer cette visibilité, il est nécessaire de préciser l'attribut comme |writable| en lui rajoutant la visibilité souhaitée :\r
+Pour les setters, ils sont toujours générer comme étant |private|. Pour changer cette visibilité, il est nécessaire de préciser l'attribut comme |writable| en lui rajoutant la visibilité souhaitée :\r
\begin{description}\r
\item[writable] Le setter automatique sera généré avec la visibilité public.\r
\item[protected writable] Le setter automatique sera généré avec la visibilité |protected|.\r
\lstinputlisting[language=Nit]{./poo/listings/accesseurs3_c.nit}\r
\r
\section{Redéfinition d'attributs}\r
-Les accesseurs automatiques sont des considérés comme des méthodes normales, ils peuvent donc être hérités et redéfinis. De plus les accesseurs automatiques peuvent être utilisés pour redéfinir des accesseurs manuels. |redef var| permet de préciser une redéfinition du getter alors que |redef writable| permet de redéfinir le setter :\r
+Les accesseurs automatiques sont considérés comme des méthodes normales, ils peuvent donc être hérités et redéfinis. De plus les accesseurs automatiques peuvent être utilisés pour redéfinir des accesseurs manuels. |redef var| permet de préciser une redéfinition du getter alors que |redef writable| permet de redéfinir le setter :\r
\lstinputlisting[language=Nit]{./poo/listings/accesseurs4_c.nit}\r
\r
\section{Opérateur isset}\r
\r
-Pour vérifier si un opérateur a été initialisée, on peut utiliser l'opérateur |isset| :\r
+Pour vérifier si un attribut a été initialisé, on peut utiliser l'opérateur |isset| :\r
\lstinputlisting[language=Nit,]{./poo/listings/isset_c.nit}\r
\r
\chapter{Constructeurs}\r
\r
\section{Redéfinition de méthodes}\r
\label{redef}\r
-La redéfinition d'une méthode héritée doit impérativement conserver la déclaration de la méthode parent (type et nombre de paramètres et la valeur de retour doivent être identiques). Si la signature de la méthode change, ce n'est plus une redéfinition mais une surcharge (et rappelez-vous : ce n'est pas autorisé en Nit !).\r
+La redéfinition d'une méthode héritée doit impérativement conserver la déclaration de la méthode parent (type et nombre de paramètres et la valeur de retour doivent être identiques). Si la signature de la méthode change, ce n'est plus une redéfinition mais une surcharge... et rappelez-vous : ce n'est pas autorisé en Nit.\r
\r
Pour redéfinir une méthode, il suffit d'utiliser le mot-clé |redef| :\r
\lstinputlisting[language=Nit]{./poo/listings/redef1_c.nit}\r
%\lstinputlisting[language=Nit]{./poo/listings/redef5_c.nit}\r
\r
\section{Polymorphisme}\r
-Le polymorphisme est la capacité, pour un même message de correspondre à plusieurs formes de traitements selon l'objet auquel ce message est adressé. La gestion du polymorphisme est assurée dynamiquement à l'exécution.\r
+Le polymorphisme est la capacité, pour un même message, de correspondre à plusieurs formes de traitements selon l'objet auquel ce message est adressé. La gestion du polymorphisme est assurée dynamiquement à l'exécution.\r
\r
L'idée est de partir d'un type et de le modifier. Par exemple, on peut créer une classe de base, puis faire des classes dérivées :\r
-\lstinputlisting[language=Nit]{./poo/listings/polymorphisme_c.nit}\r
+\lstinputlisting[language=Nit, linerange=1-35]{./poo/listings/polymorphisme_c.nit}\r
\r
On peut ensuite traiter les objets de la même manière quelques soit leur type dynamique :\r
-\lstinputlisting[language=Nit, linerange=39-43, firstnumber=last]{./poo/listings/polymorphisme_c.nit}\r
+\lstinputlisting[language=Nit, linerange=37-43, firstnumber=last]{./poo/listings/polymorphisme_c.nit}\r
\r
L'héritage définit un sous-typage implicite de la classe fille vers la classe mère : on peut affecter à une référence d'une classe n'importe quel objet d'une de ses sous classes.\r
\r
\section{Coercition}\r
-La coercition (conversion de type) peut être utilisé dans le cadre d'un cast standard grâce au mot-clé |as| :\r
+La coercition (conversion de type) peut être utilisée dans le cadre d'un cast standard grâce au mot-clé |as| :\r
\lstinputlisting[language=Nit]{./poo/listings/coercition1_c.nit}\r
\r
L'inconvénient de cette méthode est que si l'objet n'avait pas été dynamiquement typé en tant que Vache, une erreur d'exécution serait survenue lors du cast puisque celui-ci aurait échoué.\r
\chapter{Généricité et types virtuels}\r
\r
\section{Généricité}\r
-Le principe de la généricité est de factoriser les méthodes pouvant s'appliquer à n'importe quelle variable quelque soit sont type en évitant les problèmes de coercition.\r
+Le principe de la généricité est de factoriser les méthodes pouvant s'appliquer à n'importe quelle variable quel que soit son type en évitant les problèmes de coercition.\r
\r
\subsection{Généricité simple}\r
Prenons un exemple de classe non générique :\r
Si nous souhaitons pouvoir utiliser cette classe avec d'autres objets que des |String|, il serait possible de se baser sur le type le plus haut dans la hiérarchie Nit, c'est à dire |Object| :\r
\lstinputlisting[language=Nit, linerange=1-3]{./poo/listings/gen2_c.nit}\r
\r
-Voyons maintenant ce qu'il se passe quand nous utilisons cette classe avec des |Int| :\r
+Voyons maintenant ce qui se passe quand nous utilisons cette classe avec des |Int| :\r
\lstinputlisting[language=Nit, linerange=5-7, firstnumber=last]{./poo/listings/gen2_c.nit}\r
\r
Vous remarquerez qu'il est nécessaire d'utiliser un cast pour utiliser le retour du |getter| de l'attribut |valeur| puisque celui-ci est de type |Object|. Ce n'est pas pratique et potentiellement dangereux pour la stabilité du programme puisque le risque d'erreur d'exécution sur un cast qui a échoué augmente.\r
\r
Dans cette classe, le T n'est pas encore défini, cela se fera à l'instanciation. Par contre, une fois instancié avec un type, l'objet ne pourra travailler qu'avec le type de données spécifié à l'instanciation.\r
\r
-La déclaration d'une classe générique se fait en utilisant précisant le type joker (représenté par n'importe quel mot) entre crochet |[T]|. Il suffit ensuite d'implémenter les méthodes comme nous le ferions habituellement mais en remplaçant les types par le joker que nous avons défini dans la déclaration de la classe.\r
+La déclaration d'une classe générique se fait en précisant le type joker (représenté par n'importe quel mot) entre crochet |[T]|. Il suffit ensuite d'implémenter les méthodes comme nous le ferions habituellement mais en remplaçant les types par le joker que nous avons défini dans la déclaration de la classe.\r
\r
Voyons comment utiliser notre classe générique avec des entiers :\r
\lstinputlisting[language=Nit, linerange=5-6, firstnumber=last]{./poo/listings/gen3_c.nit}\r
\lstinputlisting[language=Nit]{./poo/listings/gen5_c.nit}\r
\r
\section{Types virtuels}\r
-Les types virtuels permettent définir au sein d'une classe un champ qui va contenir un type plutôt d'un objet. Ce champ peut ensuite être utilisé pour typer les paramètres et les types de retour des méthodes. Sa valeur sera exploitée à la compilation pour définir quel est le type à utiliser.\r
+Les types virtuels permettent définir au sein d'une classe un champ qui va contenir un type plutôt d'un objet. Ce champ peut ensuite être utilisé pour typer les paramètres et les types de retour des méthodes. Sa valeur sera exploitée à la compilation pour définir le type à utiliser.\r
\r
Exemple d'utilisation d'un type virtuel :\r
\lstinputlisting[language=Nit]{./poo/listings/type1_c.nit}\r
Pour l'instant il n'est pas possible d'importer des modules se trouvant dans un autre répertoire que celui où se trouvent les fichiers sources.\r
\r
\subsection{Import privé}\r
-Si on utilise le mot-clé |private| devant le |import|, le module sera importé dans le module courant comme privé. C'est à dire que tous les modules qui importeront le module courant ne verrons pas les classes et les propriétés importées.\r
+Si on utilise le mot-clé |private| devant le |import|, le module sera importé dans le module courant comme privé. C'est à dire que les modules qui importeront le module courant ne verrons pas les classes et les propriétés importées.\r
\r
\subsection{Import intrusif}\r
L'utilisation du mot-clé |intrude| avant l'import d'un module permet d'importer le module en mode intrusif, c'est à dire d'ignorer toutes les restrictions liées à la visibilité. Ainsi les méthodes déclarées |private| seront considérées comme publiques.\r
\part{Présentation de Nit}\r
\r
\chapter{Caractéristiques}\r
-Nit est un langage de programmation orienté objet dont la syntaxe est proche de celle des langages de scripts. Le but de Nit est de proposer un langage de programmation robuste typage statique, où la structure n'est pas une torture.\r
+Nit est un langage de programmation orienté objet dont la syntaxe est proche de celle des langages de scripts. Le but de Nit est de proposer un langage de programmation robuste à typage statique, où la structure n'est pas une torture.\r
\begin{description}\r
\item[Nit est compilé]Le code source de Nit est compilé pour être ensuite traduit en C.\r
\item[Nit est orienté objet]Comme la plupart des langages récents, Nit est orienté objet. Chaque fichier source contient la définition d'une ou plusieurs classes qui sont utilisées les unes avec les autres pour former une application. En Nit, TOUT est objet (Et oui même a = 0, c'est de l'objet).\r
\end{quote}\r
\r
\chapter{Historique}\r
-Nit est le descendant direct de PRM développé en 2005 au LIRMM en France. Il s'agit d'un langage jouet servant à expérimenter des traits de langage et des techniques d'implémentation.\r
+Nit est le descendant direct de PRM développé en 2005 au LIRMM en France. Il s'agissait d'un langage jouet servant à expérimenter des traits de langage et des techniques d'implémentation.\r
\r
-En 2008 nait Nit un langage plus généraliste développé conjointement par l'UQAM et le LIRMM. Il étend PRM en y ajoutant utilisabilité et robustesse.\r
+En 2008 nait Nit un langage plus généraliste développé conjointement à l'UQAM et au LIRMM. Il étend PRM en y ajoutant utilisabilité et robustesse.\r
\r
-Aujourd'hui, en 2011, le développement de Nit continu...\r
+Aujourd'hui, en 2011, le développement de Nit continue...\r
\r
\r
\chapter{Installation de Nit}\r
-Le compilateur Nit est librement accessible grâce à Git : \r
+Le compilateur Nit est librement accessible grâce à git : \r
\begin{description}\r
\item[Protocole GIT]\url{git://nitlanguage.org/nit.git}\r
\item[Protocole HTTP]\url{http://nitlanguage.org/nit.git}\r
Ça y est, le compilateur Nit est maintenant installé sur votre ordinateur !\r
\r
\chapter{Compilation et exécution}\r
-Un programme Nit est composé d'un ou plus généralement plusieurs fichiers source. N'importe quel éditeur de texte peut être utilisé pour éditer un fichier Nit.\r
+Un programme Nit est composé d'un ou plus généralement plusieurs fichiers source. N'importe quel éditeur de texte peut être utilisé pour modifier un fichier Nit.\r
\r
Ces fichiers source possèdent l'extension \og .nit \fg. Ils peuvent contenir du code, une ou plusieurs classes et/ou modules.\r
\r
-\part{Syntaxe et éléments de bases de Nit}\r
+\part{Syntaxe et éléments de base de Nit}\r
\r
\chapter{Syntaxe}\r
\r
\r
Attention : Le compilateur lèvera une exception si une variable commence par une majuscule.\r
\r
-Un identificateur ne peut pas appartenir à la liste des mots clés réservé du langage Nit :\r
+Un identificateur ne peut pas appartenir à la liste des mots clés réservés du langage Nit :\r
\begin{multicols}{4}\r
\begin{itemize}\r
\item |abort|\r
\begin{itemize}\r
\item On préfèrera utiliser la notation basée sur le soulignement pour les variables. Par exemple : |ma_variable| ;\r
\item Les types, comme les noms des classes seront écrits en \og CamelCase \fg. Par exemple : |MaClasse| ;\r
- \item L'indentation est faite avec le caractère de tabulation et est afficher comme 8 espaces ;\r
+ \item L'indentation est faite avec le caractère de tabulation et est affichée comme 8 espaces ;\r
\item Les opérateurs sont entourés d'espaces. Par exemple : |4 + 5| ou |x = 5| ;\r
\item Les spécificateurs de type (|:|) et les virgules (|,|) ont un espace après mais pas avant. Par exemple : |var x: X| ou |[1, 2, 3]| ;\r
\item Les parenthèses (|()|) et les crochets (|[]|) ne prennent pas d'espaces ;\r
\r
A l'heure actuelle, Nit ne supporte pas les commentaires multi-lignes.\r
\r
-\chapter{Éléments de bases de Nit}\r
+\chapter{Éléments de base de Nit}\r
\r
\section{Déclaration et utilisation des variables}\r
\r
Vous remarquerez qu'en Nit, il n'est pas nécessaire d'utiliser les parenthèses si le constructeur ne prend pas de paramètres.\r
\r
\section{Type nullable}\r
-Pour éviter les exceptions |nullPointerException| qui peuvent être très fréquentes sur d'autres langages, Nit impose au développeur de préciser si une variable a le droit de prendre la valeur |null|.\r
+Pour éviter les exceptions |nullPointerException| qui peuvent être fréquentes sur d'autres langages, Nit impose au développeur de préciser si une variable a le droit de prendre la valeur |null|.\r
\r
Pour préciser qu'une variable peut prendre la valeur |null|, il faut utiliser le mot clé |nullable|.\r
\r
\r
\section{Structures de contrôles}\r
\r
-Comme les autres langages de développement, Nit propose un ensemble d'instruction qui permettent d'organiser et de structurer les traitements. L'usage de ces instructions est similaire à celui rencontré à leur équivalent dans d'autres langages.\r
+Comme les autres langages de développement, Nit propose un ensemble d'instructions qui permettent d'organiser et de structurer les traitements. L'usage de ces instructions est similaire à celui rencontré à leur équivalent dans d'autres langages.\r
\r
\subsection{Boucles}\r
\subsubsection{While}\r
\lstinputlisting[language=Nit, linerange=18]{./syntaxe/listings/for_c.nit}\r
\r
\subsubsection{Loop}\r
-Les boucles infinies sont souvent utilisés accompagnées de l'instruction |break|. Elles sont utiles pour implémenter les boucles de type \og jusqu'à \fg |untill| ou pour simuler le |exit when| de Ada.\r
+Les boucles infinies sont souvent utilisés accompagnées de l'instruction |break|. Elles sont utiles pour implémenter les boucles de type \og jusqu'à \fg \textit{untill} ou pour simuler le \textit{exit when} de Ada.\r
\r
\lstinputlisting[language=Nit]{./syntaxe/listings/loop_c.nit}\r
\r
On peut aussi utiliser des clauses |else if| pour chaîner plusieurs tests :\r
\lstinputlisting[language=Nit, linerange=9-17]{./syntaxe/listings/if_c.nit}\r
\r
-Attention : Si on utilise un |else| ou un |else if|, l'instruction ne peut pas être écrit \og OnLiner \fg.\r
+Attention : Si on utilise un |else| ou un |else if|, l'instruction ne peut pas être écrit \textit{On Liner}.\r
\r
\subsection{Débranchements}\r
|continue| permet de passer immédiatement à l'itération suivante dans une boucle |for|, |while| ou |loop| :\r
L'instruction |abort| permet d'arrêter le programme en lançant une erreur fatale.\r
\r
\subsection{Assertions}\r
-L'instruction |assert| vérifie si une expression booléenne est vrai, sinon elle arrêtera le programme comme |abort|. Elle peut être combinée à une close |else| pour exécuter du code avant d'arrêter le programme :\r
+L'instruction |assert| vérifie si une expression booléenne est vrai, sinon elle arrêtera le programme comme |abort|. Elle peut être combinée à une clause |else| pour exécuter du code avant d'arrêter le programme :\r
\lstinputlisting[language=Nit]{./syntaxe/listings/assert_c.nit}\r
\r
Comme on peut le voir dans l'exemple précédent, une étiquette peut être précisée pour être affichée dans le message d'erreur.\r
\r
Attention, en Nit, la première case du tableau est la case 0 !\r
\r
+\subsection{Parcours d'un tableau}\r
+On peut parcourir les tableaux grâce à une boucle |for| :\r
+\lstinputlisting[language=Nit, linerange=3-5, firstnumber=last]{./syntaxe/listings/array2_c.nit}\r
+\r
\subsection{Initialisation explicite d'un tableau}\r
Il existe une manière plus rapide de créer les tableaux en initialisant explicitement le tableau avec les valeurs qu'il doit contenir.\r
\r
\lstinputlisting[language=Nit, linerange=1]{./syntaxe/listings/array2_c.nit}\r
\r
-\subsection{Parcours d'un tableau}\r
-On peut parcourir les tableaux grâce à une boucle |for| :\r
-\lstinputlisting[language=Nit, linerange=3-5, firstnumber=last]{./syntaxe/listings/array2_c.nit}\r
-\r
%\section{Intervalles}\r
%TODO vérifier et faire\r
%Il est possible de déclarer des intervalles |Range| basés sur des types discrets (comme |Int| par exemple). Il existe deux types d'intervalles : les intervalles ouverts |[1..5[| qui excluent le dernier élément, et les intervalles fermés |[1..5]| qui incluent le dernier élément.\r
\r
\r
\section{Conversions de types}\r
-En Nit, il n'existe pas de mot clé de transtypage. Les conversions de types se font par des méthodes. La bibliothèque standard fournit une série de classe qui contiennent des méthodes de manipulation et de conversion de types.\r
+En Nit, il n'existe pas de mot clé de transtypage. Les conversions de types se font par des méthodes. La bibliothèque standard fournit une série de classes qui contiennent des méthodes de manipulation et de conversion de types.\r
\r
\begin{tabularx}{\linewidth}{|c|X|}\r
\hline\r
\textbf{Classe} & \textbf{Rôle} \\\r
\hline\r
- Char & pour les caractères \\\r
+ \textit{Char} & pour les caractères \\\r
\hline\r
- String & pour les chaînes de caractères \\\r
+ \textit{String} & pour les chaînes de caractères \\\r
\hline\r
- Int & pour les entiers \\\r
+ \textit{Int} & pour les entiers \\\r
\hline\r
- Float & pour les nombres à virgule flottante \\\r
+ \textit{Float} & pour les nombres à virgule flottante \\\r
\hline\r
\end{tabularx}\r
\r
-Par exemple la classe Int propose les méthodes suivantes :\r
+Par exemple la classe \textit{Int} propose les méthodes suivantes :\r
\begin{description}\r
- \item[Int.to\_c:Char] Retourne le caractère correspondant.\r
- \item[Int.to\_f:Float] Retourne l'entier sous forme de |Float|.\r
- \item[Int.to\_s:String] Retourne l'entier sous forme de |String|.\r
+ \item[Int.to\_c: Char] Retourne le caractère correspondant.\r
+ \item[Int.to\_f: Float] Retourne l'entier sous forme de |Float|.\r
+ \item[Int.to\_s: String] Retourne l'entier sous forme de |String|.\r
\end{description}\r
\r
\section{Manipulation de chaînes de caractères}\r
\r
\subsection{Caractères spéciaux}\r
\r
-Dans un chaîne de caractères, plusieurs caractères particuliers doivent être échappés grâce au caractère |\| pour être utilisés. \r
+Dans une chaîne de caractères, plusieurs caractères particuliers doivent être échappés grâce au caractère |\| pour être utilisés. \r
\r
Le tableau ci-dessous recense les principaux caractères à échapper :\r
\r
Par exemple avec un Int :\r
\lstinputlisting[language=Nit, linerange=7-7]{./syntaxe/listings/string_c.nit}\r
\r
-Une notation allégée permet de concaténer une variable ou une expression avec une chaine de caractère :\r
+Une notation particulière permet d'inclure une variable ou une expression dans une chaine de caractères :\r
\lstinputlisting[language=Nit, linerange=9-10]{./syntaxe/listings/string_c.nit}\r
\r
La notation allégée appelle implicitement la méthode |to_s| sur les types autres que |String| :\r
\r
\subsection{Comparaison de chaînes de caractères}\r
\r
-En Nit il est possible de comparer deux chaînes de caractères directement grâce à l'opérateur |==|. Contrairement à Java par exemple, Nit va comparer la valeur des objets String est non pas les objets en eux-mêmes.\r
+En Nit il est possible de comparer deux chaînes de caractères directement grâce à l'opérateur |==|. Contrairement à Java par exemple, Nit va comparer la valeur des objets String est non pas les références vers les objets.\r
\lstinputlisting[language=Nit]{./syntaxe/listings/string2_c.nit}\r
\r
\subsection{Autres opérations sur les chaînes de caractères}\r
-Les méthodes |to_upper| et |to_lower| permettent respectivement d'obtenir une chaîne tout en majuscule ou tout en minuscule.\r
+Les méthodes |to_upper| et |to_lower| permettent respectivement d'obtenir une chaîne toute en majuscule ou toute en minuscule.\r
\r
La méthodes |length| permet d'obtenir la taille de la chaîne.\r
\r
Par exemple :\r
\lstinputlisting[language=Nit]{./syntaxe/listings/typage_c.nit}\r
\r
-Les instructions de contrôle de flot vont eux aussi agir sur le typage de la variable :\r
+Les instructions de contrôle de flot vont elles aussi agir sur le typage de la variable :\r
\lstinputlisting[language=Nit]{./syntaxe/listings/typage2_c.nit}\r
\r
Le typage adaptatif fonctionne aussi avec les types nullables :\r
All objects have a @to_s@ method that converts the object to a String.
@print@ is a top-level method\goto{toplevel} that takes any number of arguments\goto{vararg} and prints to the standard output.
-@print@ always add a newline, an other top-level method, @printn@ does not add the newline.
+@print@ always add a newline, another top-level method, @printn@, does not add the newline.
\begin{lst}
var x: String
print b[0] # outputs "10"
print b.length # outputs "6"
b[1] = 30
-print a.join(", ") # outputs "10, 30, 2, 3, 4, 20"
+print b.join(", ") # outputs "10, 30, 2, 3, 4, 20"
\end{lst}
Note that the type of literal arrays is deduced using the static type combination rule\goto{combination}.
\item Adaptive typing\goto{adaptive typing}.
\end{itemize}
-Some structure alters the control flow but are not described in this section: @and@, @or@, @not@\goto{Bool}, @or else@\goto{or else} and @return@\goto{return}.
+Some structures alter the control flow but are not described in this section: @and@, @or@, @not@\goto{Bool}, @or else@\goto{or else} and @return@\goto{return}.
Note that the control flow is determined only from the position, the order and the nesting of the control structures.
-The real value of the expressions used has no effect.
+The real value of the expressions used has no effect on the control flow analyses.
\begin{multicols}{2}
\begin{lst}
if true then
end
\end{lst}
-In fact, @for@ is a syntax sugar for a closure\goto{closure}.
+In fact, @for@ is syntactic sugar for a closure\goto{closure}.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{loop}\label{loop}
Unlabeled @break@ exits the current @for@, @while@, @loop@, or closure\goto{closure}.
Unlabeled @continue@ skips the current @for@, @while@, @loop@, or closure.
-@label@ can be precised with @break@ or @continue@ to designate a specific control structure (not necessary the current one).
-The corresponding @label@ must be set after the @end@ keyword of the designated control structure.
+@label@ can be used with @break@ or @continue@ to act on a specific control structure (not necessary the current one).
+The corresponding @label@ must be defined after the @end@ keyword of the designated control structure.
\begin{lst}
for i in [0..width[ do
t = "Hello" # OK
\end{lst}
-The adaptive typing flow is straightforward, therefore loops (@for@\goto{for}, @while@\goto{for}, @loop@\goto{for}) and closures\goto{closure} have a special requirement: on enter, the upper bound is set to the current static type; on exit, the upper bound is reset to its previous value.
+The adaptive typing flow is straightforward, therefore loops (@for@\goto{for}, @while@\goto{for}, @loop@\goto{for}) and closures\goto{closure} have a special requirement: on entry, the upper bound is set to the current static type; on exit, the upper bound is reset to its previous value.
\begin{lst}
var x: Object = ...
x -= 1 # OK
x = "Hello" # Compile error: expected Int
end
-# static type is Int, bound released to Object
+# static type is Int, bound reset to Object
x = "Hello" # OK
\end{lst}
end
\end{lst}
-A funnier example:
+An interesting example:
\begin{lst}
var max = 0
for i in whatever do
end
\end{lst}
-Note that a type adaptation occurs only in an @isa@ if the target type is more specific that the current type.
+Note that type adaptation occurs only in an @isa@ if the target type is more specific that the current type.
\begin{lst}
var a: Collection[Int] = ...
if a isa Comparable then
\subsection{Nullable Types}\label{null}\label{nullable}\label{or else}\label{not null}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-@null@ is a literal value that requires an explicit type acceptance.
-However, thanks to adaptive typing, it can be mainly automatic.
+@null@ is a literal value that is only accepted by some specific static types.
+However, thanks to adaptive typing, the static type management can be mainly automatic.
@nullable@ annotates types that can accept @null@ or an expression of a compatible nullable static type.
y = 1 # OK
x = null # OK
y = null # Compile error
-x = y # Compile error
-y = x # OK
+x = y # OK
+y = x # Compile error
\end{lst}
-Adaptive typing works very well with nullable types.
+Adaptive typing works well with nullable types.
\begin{lst}
var x
# The static type of x is nullable Int
\end{lst}
-Moreover, alike the @isa@ keyword, the @==@ and @!=@ operators can adapt the static type of a variable when compared to @null@.
+Moreover, like the @isa@ keyword, the @==@ and @!=@ operators can adapt the static type of a variable when compared to @null@.
\begin{lst}
var x: nullable Int = whatever
# The static type of x is nullable Int
\end{lst}
-And a last example:
+And another example:
\begin{lst}
var x: nullable Int = whatever
loop
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@as@ casts an expression to a type.
-It is either cast successfully or there is an @abort@\goto{abort}.
+The expression is either casted successfully or there is an @abort@\goto{abort}.
\begin{lst}
var x: Object = 5 # static type of x is Object
print x.as(String) # aborts: cast failed
\end{lst}
-Note that @as@ does not change the objects nor does perform conversion.
+Note that @as@ does not change the object nor does perform conversion.
\begin{lst}
var x: Object = 5 # static type of x is Object
print x.as(Int) + 10 # outputs "15"
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-@module@ declares the name of modules.
-While optional it is recommended to use it, at least to put a documentation\goto{comment}.
+@module@ declares the name of a module.
+While optional it is recommended to use it, at least for documentation purpose\goto{comment}.
The basename of the source file must match the name declared with @module@.
The extension of the source file must be @nit@.
\item @import@ indicates a public importation.
Importers of a given module will also import its publicly imported modules.
%Modules that import the current module will implicitly also import the other module.
-An analogy will be using @#include@ in a header file (@.h@) in C/C++.
+An analogy is using @#include@ in a header file (@.h@) in C/C++.
\item @private import@ indicates a private importation.
Importers of a given module will not automatically import its privately imported modules.
-An analogy will be using @#include@ in a body file (@.c@) in C/C++.
+An analogy is using @#include@ in a body file (@.c@) in C/C++.
%Modules that import the current module will not see the classes and properties imported.
%However, while the classes and properties imported are invisible, the information that the module import an other one is still public and required to compile and run the program.
\item @intrude import@ indicates an intrusive importation.
@intrude@ @import@ bypasses the @private@ visibility and gives to the importer module a full access on the imported module.
Such an import may only be considered when modules are strongly bounded and developed together.
-The closest, but insufficient, analogy will be something like including a body file in a body file in C/C++.
+The closest, but insufficient, analogy is something like including a body file in a body file in C/C++.
\end{itemize}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{Visibility}\label{visibility}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-By default, all classes\goto{class}, methods\goto{fun}, constructors\goto{init} and virtual types\goto{type} are public whitch means freely usable by any importer module.
+By default, all classes\goto{class}, methods\goto{fun}, constructors\goto{init} and virtual types\goto{type} are public which means freely usable by any importer module.
Once something is public it belongs to the API of the module and should not be changed.
@private@ indicates classes and methods that do not belong to the API.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-@interface@, @abstract class@, @class@ and @enum@ are the four kinds of classes. All these classes can be in multiple inheritance, can define new methods and redefine inherited method (yes, even interfaces). Here is the difference:
+@interface@, @abstract class@, @class@ and @enum@ are the four kinds of classes. All these classes can be in multiple inheritance, can define new methods and redefine inherited method (yes, even interfaces). Here are the differences:
\begin{itemize}
\item interfaces can only specialize other interfaces, cannot have attributes, cannot have constructors, cannot be instantiated.
\item abstract classes cannot specialize enums, can have attributes, must have constructors, cannot be instantiated.
-\item concrete classes (ie. @class@) cannot specialize enums, can have attributes, must have constructors, can be instantiated.
-\item enums (eg. @Int@ or @Bool@) can only specialize interfaces, cannot have attributes, cannot have constructors, have proper instances but they are not instantiated by the programmer---it means no @new Int@. Note that at this point there is no user-defined enums.
+\item concrete classes (i.e. @class@) cannot specialize enums, can have attributes, must have constructors, can be instantiated.
+\item enums (e.g. @Int@ or @Bool@) can only specialize interfaces, cannot have attributes, cannot have constructors, have proper instances but they are not instantiated by the programmer---it means no @new Int@. Note that at this point there is no user-defined enums.
\end{itemize}
All kinds of classes must have a name, can have some superclasses and can have some definitions of properties.
\end{itemize}
Note that the kind\goto{class} or the visibility\goto{visibility} of a class cannot be changed by a refinement.
-Therefore, it is authorized to just write @redef class X@ whatever is the kind or the visibility of @X@.
+Therefore, it is allowed to just write @redef class X@ whatever is the kind or the visibility of @X@.
In programs, the real instantiated classes are always the combination of all their refinements.
%This is quite powerful and permit a programing style only found in some dynamically typed languages or aspect-oriented languages.
@self@, the current receiver, is a special parameter.
It is not assignable but is subject to adaptive typing.
-@return@ exits the method and return to the caller.
+@return@ exits the method and returns to the caller.
In a function, the return value must be provided with a return in all control flow paths\goto{control flow}.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
The dotted notation can be chained.
A method call with no argument does not need parentheses.
-Moreover, even with arguments the parentheses are not required in the principal method of a statement.
+Moreover, even with arguments, the parentheses are not required in the principal method of a statement.
\begin{lst}
var a = [1]
a.add 5 # no () for add
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
A method can accept a variable number of arguments using ellipsis (@...@).
-The definition use @x: Foo...@ where x is the name of the parameter and @Foo@ a type.
+The definition use @x: Foo...@ where @x@ is the name of the parameter and @Foo@ a type.
Inside the body, the static type of @x@ is @Array[Foo]@.
The caller can use 0, 1, or more arguments for the parameter @x@.
Only one ellipsis is allowed in a signature.
\subsection{Top-level Methods and Main Body}\label{toplevel}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-Some function, like @print@ are usable everywhere simply without using a specific receiver.
+Some functions, like @print@, are usable everywhere simply without using a specific receiver.
Such methods are just defined outside any classes.
-In fact these methods are implicitly defined in the Object interface, therefore inherited by all classes, therefore usable everywhere.
+In fact, these methods are implicitly defined in the @Object@ interface, therefore inherited by all classes, therefore usable everywhere.
However, this principle may change in a future version.
In a module, the main body is a bunch of statements at the end of a file.
-The main body of the main module is the entry point of a program.
-In fact the main method of a program is implicitly defined as the redefinition of the method @main@ of the @Sys@ class.
-The start of the program is in fact the implicit statement @(Sys.new).main@.
+The main body of the main module is the program entry point.
+In fact, the main method of a program is implicitly defined as the redefinition of the method @main@ of the @Sys@ class; and the start of the program is the implicit statement @(Sys.new).main@.
Note that because it is a redefinition, the main part can use @super@\goto{super} to call the ``previous'' main part in the imported modules.
If there is no main part in a module, it is inherited from imported modules.
The body of @intern@ methods is provided by the compiler itself for performance or bootstrap reasons.
For the same reasons, some intern methods, like @+@ in @Int@\goto{Int} are not redefinable.
-The body of @extern@ methods is provided by libraries written in C.
-Especially the system libraries required for input/output.
+The body of @extern@ methods is provided by libraries written in C; for instance, the system libraries required for input/output.
Extern methods are always redefinable.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\end{lst}
Note that from an API point of view, there is no way to distinguish the read access of an attribute with a normal method neither to distinguish a write access of an attribute with a setter.
-Therefore, the read access of an attribute is caller a getter while the write access is called a setter.
+Therefore, the read access of an attribute is called a getter while the write access is called a setter.
\begin{lst}
var x = foo.bar # Is bar an attribute or a method?
foo.bar = y # Is bar an attribute or a setter?
\subsection{Visibility of Attributes}\label{attribute visibility}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-By default, the getter is public and the setter is private.
-The visibility of the getter can be precised with the @private@ or @protected@ keywords.
-The visibility of the setter can be specified with an additional @writable@ keyword.
+By default, a getter is public and a setter is private.
+The visibility of getters can be precised with the @private@ or @protected@ keywords.
+The visibility of setters can be specified with an additional @writable@ keyword.
\begin{lst}
class Foo
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@init@ declares constructors in concrete and in abstract classes.
-The role of the constructors is to basically initialize the attributes of the class.
+The role of constructors is basically to initialize the attributes of the class.
Constructors can have: a visibility (by default it is public), a name (by default, constructors are anonymous) and parameters.
They cannot have a return value.
var y = new Foo.herp # invoke herp
var z = new Foo.derp(1, 2) # invoke derp
\end{lst}
-Note that syntactically, @new Bar@ means ``instantiate Bar with the anonymous constructor'', and @new Bar.foo@ means ``instantiate Bar with the constructor named foo'', but @(new Bar).foo@ means ``instantiate Bar with the anonymous constructor then call the method foo on the result''.
+Note that syntactically, @new Bar@ means ``instantiate @Bar@ with the anonymous constructor'', and @new Bar.foo@ means ``instantiate @Bar@ with the constructor named @foo@'', but @(new Bar).foo@ means ``instantiate @Bar@ with the anonymous constructor then call the method @foo@ on the result''.
-Constructor can also be called by other constructors in order to factorize or delegate parts of the construction process.
+Constructors can also be called by other constructors in order to factorize or delegate parts of the construction process.
In other constructors, @init@ denotes the anonymous constructor.
\begin{lst}
class Foo
\subsection{Free and Inherited Constructors}\label{init inheritance}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-When there is no constructor defined in a concrete class or in an abstract class that specialize only interfaces (@Object@ is always a superclass), a free anonymous constructor is implicitly declared.
+When there is no constructor defined in a concrete class or in an abstract class that specializes only interfaces (@Object@ is always a superclass), a free anonymous constructor is implicitly declared.
This free constructor gathers all attributes without a initial value and assign them in order.
If all attributes have an initial value (or if there is no attributes), the free constructor has no parameters.
var f = new Foo(5, "five") # OK
\end{lst}
-When there is no constructors defined in a concrete class or in an abstract class, and that this class has only one direct superclass that is a concrete class or an abstract class, and that all attributes defined in this class have an initial value, then all constructors of the superclass are inherited.
+When there is no constructors defined in a concrete class or in an abstract class, and this class has only one direct superclass that is a concrete class or an abstract class, and all attributes defined in this class have an initial value, then all constructors of the superclass are inherited.
\begin{lst}
class Bar
@type@ declares a virtual types in a class.
A bound type is mandatory.
-Virtual types can then be used as a regular type in the class and its subclasses.
+Virtual types can then be used as regular types in the class and its subclasses.
Subclasses can also redefine it with a more specific bound type.
One can see a virtual type as an internal formal generic parameter or as a redefinable \textit{typedef}.
Closures are pieces of code that are passed to methods as additional arguments.
Closures are defined and used with the @!@ character.
-The following example shows the use of the @sort@ method of arrays (defined in the Nit standard library).
+The following example shows the use of the @sort@ method for arrays (defined in the Nit standard library).
\begin{lst}
var a = [4, 2, 9, 6]
print a.join(", ") # outputs "9, 6, 4, 2"
\end{lst}
-@!cmp@ indicates the closure parameter of the function sort.
-The documentation of the method @sort@ says that @!cmp@ is used by @sort@ to know how to compare two elements.
+@!cmp@ indicates the closure parameter of the @sort@ method.
+The documentation of the @sort@ method says that @!cmp@ is used to compare two elements.
Thus, @sort@ provides to @!cmp@ two elements and expects a Boolean result. %saying if the first element provided should be sorted before the second element provided.
-Therefore, when invoking @sort@, the programmer gets two automatic variables (one associated to each element) and is expected to return a Boolean.
+%Therefore, when invoking @sort@, the programmer gets two automatic variables (one associated to each element) and is expected to return a Boolean.
Closures can also be used to perform work.
In the following example, @file_open@ is used to open a file for reading.
end
\end{lst}
+Note that a method can have multiple closures.
+Syntactically, a closure is ended by the start of another closure or by the @end@ keyword that terminates the list of the closures.
+In the one-liner version, there is no @end@ but only one closure can be used.
Closures can access visible variables.
In the following example, the @iterate@ procedure asks for an @!each@ closure that is executed on each element of a @Collection@.
In fact, the @for@ control structure is a call of the @iterate@ method.
-The two following examples are strictly equivalent.
+The following two examples are thus strictly equivalent.
\begin{multicols}{2}
\begin{lst}
@break@ and @continue@ are extended to closures.
@continue@ exits the closure.
-If the closure expects a return value, @continue@ is also used to return the correct value.
-As with method definition, closure allows one-liners.
-Moreover, the @do continue value@ syntax can be replaced by @= value@ as in the first @sort@ example.
+If the closure expects a return value, @continue@ can also be used to return the correct value.
+As with method definition, the @do continue value@ syntax can be replaced by @= value@ as in the first @sort@ example.
@break@ exits completely the called method.
Closure parameters are declared with their signature between the prototype and the @do@ of the method.
Closure invocations in the body of the method simply use the closure name (without the @!@) like a standard call.
More than one closure parameter can be declared.
-Each one has to be declared on a separate line.
+Each has to be declared on a separate line.
%At the method invocations, the closure name is used to associate each closure definition with each closure parameter.
The order of the closure definitions does not matter.
\subsection{Default Closures}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-A default closure can be given along with the closure parameter declaration in method.
+A default closure can be given along with the closure parameter declaration in a method.
If there is no default closure, then the corresponding closure argument is mandatory.
Otherwise, if there is a default closure, the corresponding closure argument is optional.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
To conclude the explanation about closures, the last example shows the bracket operator\goto{operator} (@[]@) of the @Map@ interface.
-A map, like @HashMap@ is used to implement a dictionary that associates some objects (keys) to some other objects (items).
+A map, like @HashMap@, is used to implement a dictionary that associates some objects (keys) to some other objects (items).
The operator returns the item associated to key.
The operator has a @!def@ closure that is executed when the key is not found.
@!def@ is expected to return the item associated with the new key so it can be stored in the hashmap then returned.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-The specification of Nit is not yet finished.
-The major following features need at least to be implemented and documented:
+The specification of Nit is not yet completed.
+At least the major following features need to be implemented and documented:
\begin{itemize}
-\item User-defined @enum@ with full specialization.
-\item Union an intersection types.
+\item User-defined @enum@.
+\item Union and intersection types.
\item A usable native interface to bind Nit with system libraries and other languages.
\end{itemize}
-Moreover, a language also need a complete and stable standard library.
+Moreover, the language also needs a complete and stable standard library.
Some other topics also need a deeper analysis : exceptions, threads, parallelism, contracts, etc.
* fibonacci.nit: refine Int, the class of all integers, to add a Fibonacci function.
* procedural_array.nit: simple use of arrays without defining new classes.
* clock.nit: a simple class to track time on a wall clock.
+* int_stack.nit: simple class for a stack of integers implemented with a linked list.
* clock_more.nit: refine clock to add comparability between clocks.
* circular_list.nit: simple use of generic classes and nullable types to implement a double-linked circular list.
--- /dev/null
+# This file is part of NIT ( http://www.nitlanguage.org ).
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# An example that defines and uses stacks of integers.
+# The implementation is done with a simple linked list.
+# It features: free constructors, nullable types and some adaptive typing.
+module int_stack
+
+# A stack of integer implemented by a simple linked list.
+# Note that this is only a toy class since a real linked list will gain to use
+# generics and extends interfaces, like Collection, from the standard library.
+class IntStack
+ # The head node of the list.
+ # Null means that the stack is empty.
+ private var head: nullable ISNode = null
+
+ # Add a new integer in the stack.
+ fun push(val: Int)
+ do
+ self.head = new ISNode(val, self.head)
+ end
+
+ # Remove and return the last pushed integer.
+ # Return null if the stack is empty.
+ fun pop: nullable Int
+ do
+ var head = self.head
+ if head == null then return null
+ # Note: the followings are statically safe because of the
+ # previous 'if'.
+ var val = head.val
+ self.head = head.next
+ return val
+ end
+
+ # Return the sum of all integers of the stack.
+ # Return 0 if the stack is empty.
+ fun sumall: Int
+ do
+ var sum = 0
+ var cur = self.head
+ while cur != null do
+ # Note: the followings are statically safe because of
+ # the condition of the 'while'.
+ sum += cur.val
+ cur = cur.next
+ end
+ return sum
+ end
+
+ # Note: Because all attributes have a default value, a free constructor
+ # "init()" is implicitly defined.
+end
+
+# A node of a IntStack
+private class ISNode
+ # The integer value stored in the node.
+ var val: Int
+
+ # The next node, if any.
+ var next: nullable ISNode
+
+ # Note: A free constructor "init(val: Int, next: nullable ISNode)" is
+ # implicitly defined.
+end
+
+var l = new IntStack
+l.push(1)
+l.push(2)
+l.push(3)
+
+print l.sumall
+
+# Note: the 'for' control structure cannot be used on IntStack in its current state.
+# It requires a more advanced topic.
+# However, why not using the 'loop' control structure?
+loop
+ var i = l.pop
+ if i == null then break
+ # The following is statically safe because of the previous 'if'.
+ print i * 10
+end
+
+# Note: 'or else' is used to give an alternative of a null expression.
+l.push(5)
+print l.pop or else 0 # l.pop gives 5, so print 5
+print l.pop or else 0 # l.pop gives null, so print the alternative: 0
+
+
import string
# Patterns are string motifs.
-class Pattern
+interface Pattern
# Search `self' into `s' from a certain position.
# Return the position of the first character of the matching section.
# Return -1 if not found.
do
_messages.add(new Message(l,s))
_error_count = _error_count + 1
+ if opt_stop_on_first_error.value then check_errors
end
# Add an error, show errors and quit
else
_error_count = _error_count + 1
end
+ if opt_stop_on_first_error.value then check_errors
end
# Display an info
# Option --verbose
readable var _opt_verbose: OptionCount = new OptionCount("Verbose", "-v", "--verbose")
+ # Option --stop-on-first-error
+ readable var _opt_stop_on_first_error: OptionBool = new OptionBool("Stop on first error", "--stop-on-first-error")
+
# Verbose level
readable var _verbose_level: Int = 0
init
do
super
- option_context.add_option(opt_warn, opt_path, opt_log, opt_log_dir, opt_only_parse, opt_only_metamodel, opt_help, opt_version, opt_verbose)
+ option_context.add_option(opt_warn, opt_stop_on_first_error, opt_path, opt_log, opt_log_dir, opt_only_parse, opt_only_metamodel, opt_help, opt_version, opt_verbose)
end
# Parse and process the options given on the command line
var local_classes = mod.src_local_classes
if (local_classes.has_key(name)) then
local_class = local_classes[name]
+ _local_class = local_class
if self isa AStdClassdef then
# If we are not a special implicit class then rant
v.error(self, "Error: A class {name} is already defined at line {local_class.node.location.line_start}.")
n.next_node = self
else
local_class = new MMSrcLocalClass(mod, name, self, arity)
+ _local_class = local_class
local_classes[name] = local_class
if not mod.has_global_class_named(name) then
- local_class.new_global
+ build_class_introduction(v)
else
- local_class.set_global(mod.global_class_named(name))
+ var glob = mod.global_class_named(name)
+ build_class_refinement(v, glob)
end
end
- _local_class = local_class
v.local_class_arity = 0
v.formals = local_class.formal_dict
v.formals = null
end
+ fun build_class_introduction(v: AbsSyntaxVisitor)
+ do
+ local_class.new_global
+ var glob = local_class.global
+
+ glob.visibility_level = visibility_level
+ if self isa AStdClassdef then
+ if n_kwredef != null then
+ v.error(self, "Redef error: No class {name} is imported. Remove the redef keyword to define a new class.")
+ return
+ end
+ glob.is_interface = n_classkind.is_interface
+ glob.is_abstract = n_classkind.is_abstract
+ glob.is_enum = n_classkind.is_enum
+ end
+ end
+
+ fun build_class_refinement(v: AbsSyntaxVisitor, glob: MMGlobalClass)
+ do
+ local_class.set_global(glob)
+
+ glob.check_visibility(v, self, v.mmmodule)
+ if self isa AStdClassdef and n_kwredef == null then
+ v.error(self, "Redef error: {name} is an imported class. Add the redef keyword to refine it.")
+ return
+ end
+
+ if glob.intro.arity != _local_class.arity then
+ v.error(self, "Redef error: Formal parameter arity missmatch; got {_local_class.arity}, expected {glob.intro.arity}.")
+ end
+
+ if self isa AStdClassdef and (not glob.is_interface and n_classkind.is_interface or
+ not glob.is_abstract and n_classkind.is_abstract or
+ not glob.is_enum and n_classkind.is_enum)
+ then
+ v.error(self, "Redef error: cannot change kind of class {name}.")
+ end
+ end
+
+ redef fun accept_class_verifier(v)
+ do
+ super
+ var glob = _local_class.global
+ for c in _local_class.cshe.direct_greaters do
+ var cg = c.global
+ if glob.is_interface then
+ if cg.is_enum then
+ v.error(self, "Special error: Interface {name} try to specialise enum class {c.name}.")
+ else if not cg.is_interface then
+ v.error(self, "Special error: Interface {name} try to specialise class {c.name}.")
+ end
+ else if glob.is_enum then
+ if not cg.is_interface and not cg.is_enum then
+ v.error(self, "Special error: Enum class {name} try to specialise class {c.name}.")
+ end
+ else
+ if cg.is_enum then
+ v.error(self, "Special error: Class {name} try to specialise enum class {c.name}.")
+ end
+ end
+
+ end
+ end
+
redef fun accept_abs_syntax_visitor(v)
do
v.local_class = _local_class
do
return n_formaldefs.length
end
- redef fun accept_class_verifier(v)
- do
- super
- var glob = _local_class.global
- if glob.intro == _local_class then
- # Intro
- glob.visibility_level = visibility_level
- glob.is_interface = n_classkind.is_interface
- glob.is_abstract = n_classkind.is_abstract
- glob.is_enum = n_classkind.is_enum
- if n_kwredef != null then
- v.error(self, "Redef error: No class {name} is imported. Remove the redef keyword to define a new class.")
- end
-
- for c in _local_class.cshe.direct_greaters do
- var cg = c.global
- if glob.is_interface then
- if cg.is_enum then
- v.error(self, "Special error: Interface {name} try to specialise enum class {c.name}.")
- else if not cg.is_interface then
- v.error(self, "Special error: Interface {name} try to specialise class {c.name}.")
- end
- else if glob.is_enum then
- if not cg.is_interface and not cg.is_enum then
- v.error(self, "Special error: Enum class {name} try to specialise class {c.name}.")
- end
- else
- if cg.is_enum then
- v.error(self, "Special error: Class {name} try to specialise enum class {c.name}.")
- end
- end
-
- end
- return
- end
-
- # Redef
-
- glob.check_visibility(v, self, v.mmmodule)
- if n_kwredef == null then
- v.error(self, "Redef error: {name} is an imported class. Add the redef keyword to refine it.")
- return
- end
-
- if glob.intro.arity != _local_class.arity then
- v.error(self, "Redef error: Formal parameter arity missmatch; got {_local_class.arity}, expected {glob.intro.arity}.")
- end
-
- if
- not glob.is_interface and n_classkind.is_interface or
- not glob.is_abstract and n_classkind.is_abstract or
- not glob.is_enum and n_classkind.is_enum
- then
- v.error(self, "Redef error: cannot change kind of class {name}.")
- end
- end
redef fun visibility_level
do
#print "process {prop.local_class.mmmodule}::{prop.local_class}::{prop} from global {prop.global.local_property.local_class.mmmodule}::{prop.global.local_property.local_class}::{prop.global.local_property}"
for i in prop.prhe.direct_greaters do
var ip = i.local_class[prop.global]
- var isig = i.signature.adaptation_to(v.local_class.get_type)
+ var isig = i.signature
+ if isig == null then break # previous signature is invalid
+ isig = isig.adaptation_to(v.local_class.get_type)
if s == null then
#print "{prop.full_name} inherits signature from {ip.full_name}"
--- /dev/null
+import kernel
+
+class A[E]
+end
+
+class B[F] super A[F]
+end
+
+class C[G] super B[Int]
+end
+
+class D super C[Bool]
+end
+
+fun maybe: Bool do return true
+
+var ai = new A[Int]
+var ab = new A[Bool]
+var bi = new B[Int]
+var bb = new B[Bool]
+var ci = new C[Int]
+var cb = new C[Bool]
+var d = new D
+
+if maybe then ai = ai
+#alt1#if maybe then ai = ab
+if maybe then ai = bi
+#alt1#if maybe then ai = bb
+if maybe then ai = ci
+if maybe then ai = cb
+if maybe then ai = d
+
+#alt1#if maybe then ab = ai
+if maybe then ab = ab
+#alt1#if maybe then ab = bi
+if maybe then ab = bb
+#alt1#if maybe then ab = ci
+#alt1#if maybe then ab = cb
+#alt1#if maybe then ab = d
+
+#alt1#if maybe then bi = ai
+#alt1#if maybe then bi = ab
+if maybe then bi = bi
+#alt1#if maybe then bi = bb
+if maybe then bi = ci
+if maybe then bi = cb
+if maybe then bi = d
+
+#alt1#if maybe then bb = ai
+#alt1#if maybe then bb = ab
+#alt1#if maybe then bb = bi
+if maybe then bb = bb
+#alt1#if maybe then bb = ci
+#alt1#if maybe then bb = cb
+#alt1#if maybe then bb = d
+
+#alt1#if maybe then cb = ai
+#alt1#if maybe then ci = ab
+#alt1#if maybe then ci = bi
+#alt1#if maybe then ci = bb
+if maybe then ci = ci
+#alt1#if maybe then ci = cb
+#alt1#if maybe then ci = d
+
+#alt1#if maybe then cb = ai
+#alt1#if maybe then cb = ab
+#alt1#if maybe then cb = bi
+#alt1#if maybe then cb = bb
+#alt1#if maybe then cb = ci
+if maybe then cb = cb
+if maybe then cb = d
+
+#alt1#if maybe then d = ai
+#alt1#if maybe then d = ab
+#alt1#if maybe then d = bi
+#alt1#if maybe then d = bb
+#alt1#if maybe then d = ci
+#alt1#if maybe then d = cb
+if maybe then d = d
--- /dev/null
+import kernel
+
+class A[E]
+end
+
+class B[G] super A[Int]
+end
+
+class C super B[Bool]
+end
+
+class X
+ #1alt1#type T: A[Int]
+ #1alt2#type T: A[Bool]
+ #1alt3#type T: B[Int]
+ #1alt4#type T: B[Bool]
+ #1alt5#type T: C
+ fun toto
+ do
+ var ai = new A[Int]
+ var ab = new A[Bool]
+ var bi = new B[Int]
+ var bb = new B[Bool]
+ var c = new C
+
+ var t: T = c.as(T)
+ #alt1#if maybe then t = ai
+ #alt2#if maybe then t = ab
+ #alt3#if maybe then t = bi
+ #alt4#if maybe then t = bb
+ #alt5#if maybe then t = c
+ #alt6#if maybe then ai = t
+ #alt7#if maybe then ab = t
+ #alt8#if maybe then bi = t
+ #alt9#if maybe then bb = t
+ #alt10#if maybe then c = t
+ end
+end
+
+fun maybe: Bool do return true
+
--- /dev/null
+# This file is part of NIT ( http://www.nitlanguage.org ).
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import array
+
+#alt1#redef class Array
+#alt2#redef class Array[E: Float]
+#alt3#redef class Array[E: Float, E: Int]
+#alt4#class Array
+#alt5#class Array[E: Float]
+#alt6#class Array[E: Float, E: Int]
+end
+
+var c: Array = 5
+c.output
# See the License for the specific language governing permissions and
# limitations under the License.
-class Object
-end
+import kernel
class A
super B
--- /dev/null
+# This file is part of NIT ( http://www.nitlanguage.org ).
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import kernel
+
+class A
+ #1alt1#fun f1 do end
+ #1alt2#fun f1(i: Int) do end
+ #1alt3#fun f1: Int do return 0
+ #1alt4#fun f1(i: Int): Int do return i + 1
+end
+
+class B
+ super A
+ #alt1#redef fun f1 do end
+ #alt2#redef fun f1(i: Int) do end
+ #alt3#redef fun f1(i) do end
+ #alt4#redef fun f1 do return 0
+ #alt5#redef fun f1(i: Int) do return i + 1
+ #alt6#redef fun f1(i) do return i + 1
+ #alt7#redef fun f1: Int do return 0
+ #alt8#redef fun f1(i: Int): Int do return i + 1
+ #alt9#redef fun f1(i): Int do return i + 1
+end
+
--- /dev/null
+# This file is part of NIT ( http://www.nitlanguage.org ).
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import kernel
+
+class A
+ #1alt1#fun f1 do end
+ #1alt2#fun f1(i: Int) do end
+ #1alt3#fun f1: Int do return 0
+ #1alt4#fun f1(i: Int): Int do return i + 1
+end
+
+class B
+ super A
+ #alt1#fun f1 do end
+ #alt2#fun f1(i: Int) do end
+ #alt3#fun f1(i) do end
+ #alt4#fun f1 do return 0
+ #alt5#fun f1(i: Int) do return i + 1
+ #alt6#fun f1(i) do return i + 1
+ #alt7#fun f1: Int do return 0
+ #alt8#fun f1(i: Int): Int do return i + 1
+ #alt9#fun f1(i): Int do return i + 1
+end
+
--- /dev/null
+# This file is part of NIT ( http://www.nitlanguage.org ).
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import kernel
+
+class A
+ fun foo: Fail do return 1
+end
+
+class B
+ super A
+ redef fun foo do return 2
+end
+
+class C
+ super A
+ redef fun foo: Int do return 3
+end
--- /dev/null
+import kernel
+
+class G[E]
+end
+
+#alt1# class H[E: Fail] end
+
+class A
+ #alt2#super Fail
+ #alt3#super G[Fail]
+ #alt2#super Fail[G]
+
+ #alt4#var v: Fail
+ #alt4#fun f(f: Fail): Fail do return f + 1
+ #alt5#var v: Fail
+ #alt5#fun f(f: Fail): Fail do return f + 1
+
+ fun f2 do
+ #alt6#var x: Fail
+ #alt7#var y = new Fail
+ var z = 1
+ var b = z isa Fail
+ z = b + 1
+ var c = z.as(Fail)
+ z = c + 1
+ end
+end
+
+class B
+ super A
+ #alt4# redef fun v do return super + 1
+ #alt4# redef fun f(f) do return f + 1
+ #alt5# redef fun v: Fail do return super + 1
+ #alt5# redef fun f(f: Fail): Fail do return f + 1
+end
--- /dev/null
+./base_upcast2.nit:26,10: Type error: class T not found in module base_upcast2.
+./base_upcast2.nit:26,19: Type error: class T not found in module base_upcast2.
--- /dev/null
+alt/base_upcast2_1alt1_alt10.nit:36,21: Type error: expected C, got T
--- /dev/null
+alt/base_upcast2_1alt1_alt2.nit:28,21--22: Type error: expected T, got A[Bool]
--- /dev/null
+alt/base_upcast2_1alt1_alt7.nit:33,22: Type error: expected A[Bool], got T
--- /dev/null
+alt/base_upcast2_1alt1_alt8.nit:34,22: Type error: expected B[Int], got T
--- /dev/null
+alt/base_upcast2_1alt1_alt9.nit:35,22: Type error: expected B[Bool], got T
--- /dev/null
+alt/base_upcast2_1alt2_alt1.nit:27,21--22: Type error: expected T, got A[Int]
--- /dev/null
+alt/base_upcast2_1alt2_alt10.nit:36,21: Type error: expected C, got T
--- /dev/null
+alt/base_upcast2_1alt2_alt3.nit:29,21--22: Type error: expected T, got B[Int]
--- /dev/null
+alt/base_upcast2_1alt2_alt4.nit:30,21--22: Type error: expected T, got B[Bool]
--- /dev/null
+alt/base_upcast2_1alt2_alt5.nit:31,21: Type error: expected T, got C
--- /dev/null
+alt/base_upcast2_1alt2_alt6.nit:32,22: Type error: expected A[Int], got T
--- /dev/null
+alt/base_upcast2_1alt2_alt8.nit:34,22: Type error: expected B[Int], got T
--- /dev/null
+alt/base_upcast2_1alt2_alt9.nit:35,22: Type error: expected B[Bool], got T
--- /dev/null
+alt/base_upcast2_1alt3_alt1.nit:27,21--22: Type error: expected T, got A[Int]
--- /dev/null
+alt/base_upcast2_1alt3_alt10.nit:36,21: Type error: expected C, got T
--- /dev/null
+alt/base_upcast2_1alt3_alt2.nit:28,21--22: Type error: expected T, got A[Bool]
--- /dev/null
+alt/base_upcast2_1alt3_alt4.nit:30,21--22: Type error: expected T, got B[Bool]
--- /dev/null
+alt/base_upcast2_1alt3_alt5.nit:31,21: Type error: expected T, got C
--- /dev/null
+alt/base_upcast2_1alt3_alt7.nit:33,22: Type error: expected A[Bool], got T
--- /dev/null
+alt/base_upcast2_1alt3_alt9.nit:35,22: Type error: expected B[Bool], got T
--- /dev/null
+alt/base_upcast2_1alt4_alt1.nit:27,21--22: Type error: expected T, got A[Int]
--- /dev/null
+alt/base_upcast2_1alt4_alt10.nit:36,21: Type error: expected C, got T
--- /dev/null
+alt/base_upcast2_1alt4_alt2.nit:28,21--22: Type error: expected T, got A[Bool]
--- /dev/null
+alt/base_upcast2_1alt4_alt3.nit:29,21--22: Type error: expected T, got B[Int]
--- /dev/null
+alt/base_upcast2_1alt4_alt7.nit:33,22: Type error: expected A[Bool], got T
--- /dev/null
+alt/base_upcast2_1alt4_alt8.nit:34,22: Type error: expected B[Int], got T
--- /dev/null
+alt/base_upcast2_1alt5_alt1.nit:27,21--22: Type error: expected T, got A[Int]
--- /dev/null
+alt/base_upcast2_1alt5_alt2.nit:28,21--22: Type error: expected T, got A[Bool]
--- /dev/null
+alt/base_upcast2_1alt5_alt3.nit:29,21--22: Type error: expected T, got B[Int]
--- /dev/null
+alt/base_upcast2_1alt5_alt4.nit:30,21--22: Type error: expected T, got B[Bool]
--- /dev/null
+alt/base_upcast2_1alt5_alt7.nit:33,22: Type error: expected A[Bool], got T
--- /dev/null
+alt/base_upcast2_1alt5_alt8.nit:34,22: Type error: expected B[Int], got T
--- /dev/null
+alt/base_upcast2_alt1.nit:26,10: Type error: class T not found in module base_upcast2_alt1.
+alt/base_upcast2_alt1.nit:26,19: Type error: class T not found in module base_upcast2_alt1.
--- /dev/null
+alt/base_upcast2_alt10.nit:26,10: Type error: class T not found in module base_upcast2_alt10.
+alt/base_upcast2_alt10.nit:26,19: Type error: class T not found in module base_upcast2_alt10.
--- /dev/null
+alt/base_upcast2_alt2.nit:26,10: Type error: class T not found in module base_upcast2_alt2.
+alt/base_upcast2_alt2.nit:26,19: Type error: class T not found in module base_upcast2_alt2.
--- /dev/null
+alt/base_upcast2_alt3.nit:26,10: Type error: class T not found in module base_upcast2_alt3.
+alt/base_upcast2_alt3.nit:26,19: Type error: class T not found in module base_upcast2_alt3.
--- /dev/null
+alt/base_upcast2_alt4.nit:26,10: Type error: class T not found in module base_upcast2_alt4.
+alt/base_upcast2_alt4.nit:26,19: Type error: class T not found in module base_upcast2_alt4.
--- /dev/null
+alt/base_upcast2_alt5.nit:26,10: Type error: class T not found in module base_upcast2_alt5.
+alt/base_upcast2_alt5.nit:26,19: Type error: class T not found in module base_upcast2_alt5.
--- /dev/null
+alt/base_upcast2_alt6.nit:26,10: Type error: class T not found in module base_upcast2_alt6.
+alt/base_upcast2_alt6.nit:26,19: Type error: class T not found in module base_upcast2_alt6.
--- /dev/null
+alt/base_upcast2_alt7.nit:26,10: Type error: class T not found in module base_upcast2_alt7.
+alt/base_upcast2_alt7.nit:26,19: Type error: class T not found in module base_upcast2_alt7.
--- /dev/null
+alt/base_upcast2_alt8.nit:26,10: Type error: class T not found in module base_upcast2_alt8.
+alt/base_upcast2_alt8.nit:26,19: Type error: class T not found in module base_upcast2_alt8.
--- /dev/null
+alt/base_upcast2_alt9.nit:26,10: Type error: class T not found in module base_upcast2_alt9.
+alt/base_upcast2_alt9.nit:26,19: Type error: class T not found in module base_upcast2_alt9.
--- /dev/null
+alt/base_upcast_alt1.nit:26,20--21: Type error: expected A[Int], got A[Bool]
+alt/base_upcast_alt1.nit:28,20--21: Type error: expected A[Int], got B[Bool]
+alt/base_upcast_alt1.nit:33,20--21: Type error: expected A[Bool], got A[Int]
+alt/base_upcast_alt1.nit:35,20--21: Type error: expected A[Bool], got B[Int]
+alt/base_upcast_alt1.nit:37,20--21: Type error: expected A[Bool], got C[Int]
+alt/base_upcast_alt1.nit:38,20--21: Type error: expected A[Bool], got C[Bool]
+alt/base_upcast_alt1.nit:39,20: Type error: expected A[Bool], got D
+alt/base_upcast_alt1.nit:41,20--21: Type error: expected B[Int], got A[Int]
+alt/base_upcast_alt1.nit:42,20--21: Type error: expected B[Int], got A[Bool]
+alt/base_upcast_alt1.nit:44,20--21: Type error: expected B[Int], got B[Bool]
+alt/base_upcast_alt1.nit:49,20--21: Type error: expected B[Bool], got A[Int]
+alt/base_upcast_alt1.nit:50,20--21: Type error: expected B[Bool], got A[Bool]
+alt/base_upcast_alt1.nit:51,20--21: Type error: expected B[Bool], got B[Int]
+alt/base_upcast_alt1.nit:53,20--21: Type error: expected B[Bool], got C[Int]
+alt/base_upcast_alt1.nit:54,20--21: Type error: expected B[Bool], got C[Bool]
+alt/base_upcast_alt1.nit:55,20: Type error: expected B[Bool], got D
+alt/base_upcast_alt1.nit:57,20--21: Type error: expected C[Bool], got A[Int]
+alt/base_upcast_alt1.nit:58,20--21: Type error: expected C[Int], got A[Bool]
+alt/base_upcast_alt1.nit:59,20--21: Type error: expected C[Int], got B[Int]
+alt/base_upcast_alt1.nit:60,20--21: Type error: expected C[Int], got B[Bool]
+alt/base_upcast_alt1.nit:62,20--21: Type error: expected C[Int], got C[Bool]
+alt/base_upcast_alt1.nit:63,20: Type error: expected C[Int], got D
+alt/base_upcast_alt1.nit:65,20--21: Type error: expected C[Bool], got A[Int]
+alt/base_upcast_alt1.nit:66,20--21: Type error: expected C[Bool], got A[Bool]
+alt/base_upcast_alt1.nit:67,20--21: Type error: expected C[Bool], got B[Int]
+alt/base_upcast_alt1.nit:68,20--21: Type error: expected C[Bool], got B[Bool]
+alt/base_upcast_alt1.nit:69,20--21: Type error: expected C[Bool], got C[Int]
+alt/base_upcast_alt1.nit:73,19--20: Type error: expected D, got A[Int]
+alt/base_upcast_alt1.nit:74,19--20: Type error: expected D, got A[Bool]
+alt/base_upcast_alt1.nit:75,19--20: Type error: expected D, got B[Int]
+alt/base_upcast_alt1.nit:76,19--20: Type error: expected D, got B[Bool]
+alt/base_upcast_alt1.nit:77,19--20: Type error: expected D, got C[Int]
+alt/base_upcast_alt1.nit:78,19--20: Type error: expected D, got C[Bool]
--- /dev/null
+./error_class_generic.nit:23,1--3: Syntax error: unexpected token.
--- /dev/null
+alt/error_class_generic_alt1.nit:17,1--17: Redef error: Formal parameter arity missmatch; got 0, expected 1.
--- /dev/null
+alt/error_class_generic_alt2.nit:18,19--26: Redef error: Cannot change formal parameter type of class Array; got Float, expected nullable Object.
--- /dev/null
+alt/error_class_generic_alt3.nit:17,1--19,34: Redef error: Formal parameter arity missmatch; got 2, expected 1.
--- /dev/null
+alt/error_class_generic_alt4.nit:17,1--20,11: Redef error: Array is an imported class. Add the redef keyword to refine it.
--- /dev/null
+alt/error_class_generic_alt5.nit:17,1--21,20: Redef error: Array is an imported class. Add the redef keyword to refine it.
--- /dev/null
+alt/error_class_generic_alt6.nit:17,1--22,28: Redef error: Array is an imported class. Add the redef keyword to refine it.
--- /dev/null
+alt/error_redef2_1alt1_alt1.nit:26,2--7: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt1_alt2.nit:26,2--27,14: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt1_alt3.nit:26,2--28,9: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt1_alt4.nit:26,2--29,19: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt1_alt5.nit:26,2--30,31: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt1_alt6.nit:26,2--31,26: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt1_alt7.nit:26,2--32,24: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt1_alt8.nit:26,2--33,36: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt1_alt9.nit:34,9: Syntax error: untyped parameter.
+alt/error_redef2_1alt1_alt9.nit:26,2--34,31: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt2_alt1.nit:26,2--7: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt2_alt2.nit:26,2--27,14: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt2_alt3.nit:26,2--28,9: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt2_alt4.nit:26,2--29,19: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt2_alt5.nit:26,2--30,31: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt2_alt6.nit:26,2--31,26: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt2_alt7.nit:26,2--32,24: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt2_alt8.nit:26,2--33,36: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt2_alt9.nit:34,9: Syntax error: untyped parameter.
+alt/error_redef2_1alt2_alt9.nit:26,2--34,31: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt3_alt1.nit:26,2--7: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt3_alt2.nit:26,2--27,14: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt3_alt3.nit:26,2--28,9: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt3_alt4.nit:26,2--29,19: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt3_alt5.nit:26,2--30,31: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt3_alt6.nit:26,2--31,26: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt3_alt7.nit:26,2--32,24: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt3_alt8.nit:26,2--33,36: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt3_alt9.nit:34,9: Syntax error: untyped parameter.
+alt/error_redef2_1alt3_alt9.nit:26,2--34,31: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt4_alt1.nit:26,2--7: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt4_alt2.nit:26,2--27,14: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt4_alt3.nit:26,2--28,9: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt4_alt4.nit:26,2--29,19: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt4_alt5.nit:26,2--30,31: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt4_alt6.nit:26,2--31,26: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt4_alt7.nit:26,2--32,24: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt4_alt8.nit:26,2--33,36: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_1alt4_alt9.nit:34,9: Syntax error: untyped parameter.
+alt/error_redef2_1alt4_alt9.nit:26,2--34,31: Redef error: B::f1 is an inherited property. To redefine it, add the redef keyword.
--- /dev/null
+alt/error_redef2_alt3.nit:28,9: Error: Untyped parameter.
--- /dev/null
+alt/error_redef2_alt4.nit:29,12--19: Error: Return with value in a procedure.
--- /dev/null
+alt/error_redef2_alt5.nit:30,20--31: Error: Return with value in a procedure.
--- /dev/null
+alt/error_redef2_alt6.nit:31,9: Error: Untyped parameter.
--- /dev/null
+alt/error_redef2_alt9.nit:34,9: Syntax error: untyped parameter.
+alt/error_redef2_alt9.nit:34,9: Error: Untyped parameter.
--- /dev/null
+alt/error_redef_1alt1_alt2.nit:26,2--27,20: Redef error: B::f1 redefines A::f1 with 0 parameter(s).
--- /dev/null
+alt/error_redef_1alt1_alt3.nit:26,2--28,15: Redef error: B::f1 redefines A::f1 with 0 parameter(s).
--- /dev/null
+alt/error_redef_1alt1_alt4.nit:29,18--25: Error: Return with value in a procedure.
--- /dev/null
+alt/error_redef_1alt1_alt5.nit:26,2--30,37: Redef error: B::f1 redefines A::f1 with 0 parameter(s).
--- /dev/null
+alt/error_redef_1alt1_alt6.nit:26,2--31,32: Redef error: B::f1 redefines A::f1 with 0 parameter(s).
--- /dev/null
+alt/error_redef_1alt1_alt7.nit:26,2--32,30: Redef error: The function B::f1 redefines the procedure A::f1.
--- /dev/null
+alt/error_redef_1alt1_alt8.nit:26,2--33,42: Redef error: B::f1 redefines A::f1 with 0 parameter(s).
+alt/error_redef_1alt1_alt8.nit:26,2--33,42: Redef error: The function B::f1 redefines the procedure A::f1.
--- /dev/null
+alt/error_redef_1alt1_alt9.nit:34,15: Syntax error: untyped parameter.
+alt/error_redef_1alt1_alt9.nit:26,2--34,37: Redef error: B::f1 redefines A::f1 with 0 parameter(s).
--- /dev/null
+alt/error_redef_1alt2_alt1.nit:26,2--13: Redef error: B::f1 redefines A::f1 with 1 parameter(s).
--- /dev/null
+alt/error_redef_1alt2_alt4.nit:26,2--29,25: Redef error: B::f1 redefines A::f1 with 1 parameter(s).
--- /dev/null
+alt/error_redef_1alt2_alt5.nit:30,26--37: Error: Return with value in a procedure.
--- /dev/null
+alt/error_redef_1alt2_alt6.nit:31,21--32: Error: Return with value in a procedure.
--- /dev/null
+alt/error_redef_1alt2_alt7.nit:26,2--32,30: Redef error: B::f1 redefines A::f1 with 1 parameter(s).
+alt/error_redef_1alt2_alt7.nit:26,2--32,30: Redef error: The function B::f1 redefines the procedure A::f1.
--- /dev/null
+alt/error_redef_1alt2_alt8.nit:26,2--33,42: Redef error: The function B::f1 redefines the procedure A::f1.
--- /dev/null
+alt/error_redef_1alt2_alt9.nit:34,15: Syntax error: untyped parameter.
--- /dev/null
+alt/error_redef_1alt3_alt1.nit:26,2--13: Control error: Reached end of function (a 'return' with a value was expected).
--- /dev/null
+alt/error_redef_1alt3_alt2.nit:26,2--27,20: Redef error: B::f1 redefines A::f1 with 0 parameter(s).
+alt/error_redef_1alt3_alt2.nit:26,2--27,20: Redef error: The procedure B::f1 redefines the function A::f1.
--- /dev/null
+alt/error_redef_1alt3_alt3.nit:26,2--28,15: Redef error: B::f1 redefines A::f1 with 0 parameter(s).
--- /dev/null
+alt/error_redef_1alt3_alt5.nit:26,2--30,37: Redef error: B::f1 redefines A::f1 with 0 parameter(s).
+alt/error_redef_1alt3_alt5.nit:26,2--30,37: Redef error: The procedure B::f1 redefines the function A::f1.
--- /dev/null
+alt/error_redef_1alt3_alt6.nit:26,2--31,32: Redef error: B::f1 redefines A::f1 with 0 parameter(s).
--- /dev/null
+alt/error_redef_1alt3_alt8.nit:26,2--33,42: Redef error: B::f1 redefines A::f1 with 0 parameter(s).
--- /dev/null
+alt/error_redef_1alt3_alt9.nit:34,15: Syntax error: untyped parameter.
+alt/error_redef_1alt3_alt9.nit:26,2--34,37: Redef error: B::f1 redefines A::f1 with 0 parameter(s).
--- /dev/null
+alt/error_redef_1alt4_alt1.nit:26,2--13: Redef error: B::f1 redefines A::f1 with 1 parameter(s).
--- /dev/null
+alt/error_redef_1alt4_alt2.nit:26,2--27,20: Redef error: The procedure B::f1 redefines the function A::f1.
--- /dev/null
+alt/error_redef_1alt4_alt3.nit:26,2--28,15: Control error: Reached end of function (a 'return' with a value was expected).
--- /dev/null
+alt/error_redef_1alt4_alt4.nit:26,2--29,25: Redef error: B::f1 redefines A::f1 with 1 parameter(s).
--- /dev/null
+alt/error_redef_1alt4_alt5.nit:26,2--30,37: Redef error: The procedure B::f1 redefines the function A::f1.
--- /dev/null
+alt/error_redef_1alt4_alt7.nit:26,2--32,30: Redef error: B::f1 redefines A::f1 with 1 parameter(s).
--- /dev/null
+alt/error_redef_1alt4_alt9.nit:34,15: Syntax error: untyped parameter.
--- /dev/null
+alt/error_redef_alt1.nit:26,2--13: Error: No property B::f1 is inherited. Remove the redef keyword to define a new property.
--- /dev/null
+alt/error_redef_alt2.nit:26,2--27,20: Error: No property B::f1 is inherited. Remove the redef keyword to define a new property.
--- /dev/null
+alt/error_redef_alt3.nit:28,15: Error: Untyped parameter.
+alt/error_redef_alt3.nit:26,2--28,15: Error: No property B::f1 is inherited. Remove the redef keyword to define a new property.
--- /dev/null
+alt/error_redef_alt4.nit:26,2--29,25: Error: No property B::f1 is inherited. Remove the redef keyword to define a new property.
--- /dev/null
+alt/error_redef_alt5.nit:26,2--30,37: Error: No property B::f1 is inherited. Remove the redef keyword to define a new property.
--- /dev/null
+alt/error_redef_alt6.nit:31,15: Error: Untyped parameter.
+alt/error_redef_alt6.nit:26,2--31,32: Error: No property B::f1 is inherited. Remove the redef keyword to define a new property.
--- /dev/null
+alt/error_redef_alt7.nit:26,2--32,30: Error: No property B::f1 is inherited. Remove the redef keyword to define a new property.
--- /dev/null
+alt/error_redef_alt8.nit:26,2--33,42: Error: No property B::f1 is inherited. Remove the redef keyword to define a new property.
--- /dev/null
+alt/error_redef_alt9.nit:34,15: Syntax error: untyped parameter.
+alt/error_redef_alt9.nit:34,15: Error: Untyped parameter.
+alt/error_redef_alt9.nit:26,2--34,37: Error: No property B::f1 is inherited. Remove the redef keyword to define a new property.
--- /dev/null
+./error_signature.nit:18,11--14: Type error: class Fail not found in module error_signature.
--- /dev/null
+./error_type_unk.nit:22,17--20: Type error: class Fail not found in module error_type_unk.
+./error_type_unk.nit:24,16--19: Type error: class Fail not found in module error_type_unk.
--- /dev/null
+alt/error_type_unk_alt1.nit:6,13--16: Type error: class Fail not found in module error_type_unk_alt1.
--- /dev/null
+alt/error_type_unk_alt2.nit:9,8--11: Type error: class Fail not found in module error_type_unk_alt2.
+alt/error_type_unk_alt2.nit:11,8--11: Type error: class Fail not found in module error_type_unk_alt2.
--- /dev/null
+alt/error_type_unk_alt3.nit:10,10--13: Type error: class Fail not found in module error_type_unk_alt3.
--- /dev/null
+alt/error_type_unk_alt4.nit:13,9--12: Type error: class Fail not found in module error_type_unk_alt4.
+alt/error_type_unk_alt4.nit:14,11--14: Type error: class Fail not found in module error_type_unk_alt4.
--- /dev/null
+alt/error_type_unk_alt5.nit:15,9--12: Type error: class Fail not found in module error_type_unk_alt5.
+alt/error_type_unk_alt5.nit:16,11--14: Type error: class Fail not found in module error_type_unk_alt5.
+alt/error_type_unk_alt5.nit:33,16--19: Type error: class Fail not found in module error_type_unk_alt5.
+alt/error_type_unk_alt5.nit:34,18--21: Type error: class Fail not found in module error_type_unk_alt5.
--- /dev/null
+alt/error_type_unk_alt6.nit:19,10--13: Type error: class Fail not found in module error_type_unk_alt6.
+alt/error_type_unk_alt6.nit:22,17--20: Type error: class Fail not found in module error_type_unk_alt6.
+alt/error_type_unk_alt6.nit:24,16--19: Type error: class Fail not found in module error_type_unk_alt6.
--- /dev/null
+alt/error_type_unk_alt7.nit:20,15--18: Type error: class Fail not found in module error_type_unk_alt7.
+alt/error_type_unk_alt7.nit:22,17--20: Type error: class Fail not found in module error_type_unk_alt7.
+alt/error_type_unk_alt7.nit:24,16--19: Type error: class Fail not found in module error_type_unk_alt7.
--- /dev/null
+6
+30
+20
+10
+5
+0
usage: nitc [options] file...
-W, --warn Show warnings
+ --stop-on-first-error Stop on first error
-I, --path Set include path for loaders (may be used more than once)
--log Generate various log files
--log-dir Directory where to generate log files
usage: nitdoc [options] file...
- -W, --warn Show warnings
- -I, --path Set include path for loaders (may be used more than once)
- --log Generate various log files
- --log-dir Directory where to generate log files
- --only-parse Only proceed to parse step of loaders
- --only-metamodel Stop after meta-model processing
- -h, -?, --help Show Help (This screen)
- --version Show version and exit
- -v, --verbose Verbose
- -d, --dir Directory where doc is generated
+ -W, --warn Show warnings
+ --stop-on-first-error Stop on first error
+ -I, --path Set include path for loaders (may be used more than once)
+ --log Generate various log files
+ --log-dir Directory where to generate log files
+ --only-parse Only proceed to parse step of loaders
+ --only-metamodel Stop after meta-model processing
+ -h, -?, --help Show Help (This screen)
+ --version Show version and exit
+ -v, --verbose Verbose
+ -d, --dir Directory where doc is generated
type U: B
fun foo(a: T) do a.out
fun bar(b: U) do b.out
- fun baz(i: Int) do i.out
+ fun baz(i: C) do i.out
fun out do 'A'.output
init do end
class B
super A
redef type T: B
- redef type U: Int
+ redef type U: C
redef fun foo(a: T) do a.out
redef fun bar(b: U) do b.out
- redef fun baz(i: Int) do i.out
+ redef fun baz(i: C) do i.out
redef fun out do 'B'.output
init do end
end
-redef class Int
+class C
super B
- redef type T: Int
+ redef type T: C
redef fun foo(a: T) do a.out
redef fun bar(b: U) do b.out
- redef fun output is intern
+ redef fun output do i.output
redef fun out
do
var i: Object = self
- if i isa Int then
+ if i isa C then
i.output
else
'X'.output
end
end
-
+ var i: Int
+ init (i:Int) do self.i = i
end
-
var a = new A
var b = new B
var ab: A = b
-var i = 5
+var i = new C(5)
var ai: A = i
var bi: B = i
return new B
end
- fun baz: Int
+ fun baz: C
do
- return 5
+ return new C(5)
end
redef fun output
do
return new B
end
- redef fun bar: Int
+ redef fun bar: C
do
- return 6
+ return new C(6)
end
- redef fun baz: Int
+ redef fun baz: C
do
- return 7
+ return new C(7)
end
redef fun output
do
init do end
end
-
-redef class Int
+class C
super B
- redef fun foo: Int
+ redef fun foo: C
do
- return 8
+ return new C(8)
end
- redef fun bar: Int
+ redef fun bar: C
do
- return 9
+ return new C(9)
end
- redef fun output is intern
+ redef fun output do i.output
+ var i: Int
+ init (i: Int) do self.i = i
end
-
var a = new A
var b = new B
var ab: A = b
-var i = 5
+var i = new C(5)
var ai: A = i
var bi: B = i
NITC=$recent
}
+make_alts0()
+{
+ ii="$1"
+ xalt="$2"
+ fs=""
+ for alt in `sed -n "s/.*#!*\($xalt[0-9]*\)#.*/\1/p" "$ii" | sort -u`; do
+ f=`basename "$ii" .nit`
+ d=`dirname "$ii"`
+ ff="$f"
+ i="$ii"
+
+ if [ "x$alt" != "x" ]; then
+ test -d alt || mkdir -p alt
+ i="alt/${f}_$alt.nit"
+ ff="${ff}_$alt"
+ sed "s/#$alt#//g;/#!$alt#/d" "$ii" > "$i"
+ fi
+ ff="$ff$MARK"
+ fs="$fs $i"
+ done
+ echo "$fs"
+}
+make_alts()
+{
+ ii="$1"
+ fs="$1"
+ for xalt in `sed -n 's/.*#!*\([0-9]*alt\)[0-9]*#.*/\1/p' "$ii" | sort -u`; do
+ fs2=""
+ for f in $fs; do
+ fs2="$fs2 `make_alts0 $f $xalt`"
+ done
+ fs="$fs $fs2"
+ done
+ echo "$fs"
+}
+
# The default nitc compiler
[ -z "$NITC" ] && find_nitc
ok=""
nok=""
+
for ii in "$@"; do
if [ ! -f $ii ]; then
echo "File '$ii' does not exist."
tmp=${ii/../AA}
if [ "x$tmp" = "x$ii" ]; then
- oincludes="-I . -I ../lib/standard -I ../lib/standard/collection"
+ includes="-I . -I ../lib/standard -I ../lib/standard/collection -I alt"
else
- oincludes=""
+ includes="-I alt"
fi
- for alt in "" `sed -n 's/.*#!*\(alt[0-9]*\)#.*/\1/p' "$ii" | sort -u`; do
- f=`basename "$ii" .nit`
- d=`dirname "$ii"`
- ff="$f"
- i="$ii"
- includes="$oincludes"
-
- if [ "x$alt" != "x" ]; then
- test -d alt || mkdir -p alt
- i="alt/${f}_$alt.nit"
- ff="${ff}_$alt"
- sed "s/#$alt#//g;/#!$alt#/d" "$ii" > "$i"
- includes="$includes -I alt"
- fi
- ff="$ff$MARK"
-
- echo -n "=> $i: "
+ f=`basename "$ii" .nit`
+ for i in `make_alts $ii`; do
+ ff=`basename $i .nit`
+ echo -n "=> $ff: "
rm -rf "$ff.res" "$ff.err" "$ff.write" "$ff.bin" 2> /dev/null
nitlanguage / nit.git / commitdiff