Libraries can be private.

docs/language/dartLangSpec.tex

 \documentclass{article}
 \usepackage{epsfig}
 \usepackage{dart}
 \usepackage{bnf}
 \usepackage{hyperref}
 \newcommand{\code}[1]{{\sf #1}}
 \title{Dart Programming Language  Specification \\
-{\large Version 1.11}}
+{\large Version 1.2}}

[ahe, 2014/02/25 10:28:20]

I believe 1.11 is larger than 1.2, so this version number is a bit surprising.

 \author{The Dart Team}
 \begin{document}
 \maketitle
 
 \tableofcontents
 
 
 \newpage
 
 \pagestyle{myheadings}
@@ skipping 183 matching lines @@
 Good tooling should of course endeavor to inform programmers of such situations (discreetly). For example, an identifier that is both inherited and lexically visible could be highlighted (via underlining or colorization). Better yet, tight integration of source control with language aware tools would detect such changes when they occur. 
  
 }
 
 
 
 
 \subsection{Privacy}
 \label{privacy}
 
-Dart supports two levels of privacy: {\em public} and {\em private}. A declaration is {\em private} iff its name begins with an underscore (the \_ character) otherwise it is {\em public.} 
+Dart supports two levels of privacy: {\em public} and {\em private}.  A declaration is {\em private} iff its name is private, otherwise it is {\em public.}  A  name $q$ is private iff any one of the identifiers that comprise $q$ is private,  otherwise it is {\em public.}  An identifier is private iff it

[ahe, 2014/02/20 15:51:39]

What is a "declaration"?

What is "its name" (that is, the name of a declaration)?

In particular, where is this defined for libraries?

+begins with an underscore (the \_ character) otherwise it is {\em public.} 
+
 A declaration $m$ is {\em accessible to library $L$}  if $m$ is declared in $L$ or if $m$ is public.
 
 \commentary{
 This means private declarations may only be accessed within the library in which they are declared.
 }
 
 Privacy applies only to declarations within a library, not to library declarations themselves. 
 
-\rationale{
-Libraries do not reference each other by name and so the idea of a private library is meaningless.
-Thus, if the name of a library begins with an underscore, it has no special significance.
+\rationale{Libraries do not reference each other by name and so the idea of a private library is meaningless.
+Thus, if the name of a library begins with an underscore, it has no effect on the accessibility of the library or its members.
 }
 
 \rationale{Privacy is, at this point, a static notion tied to a particular piece of code (a library). It is designed to support software engineering concerns rather than security concerns. Untrusted code should always run in an another isolate.  It is possible that libraries will become first class objects and privacy will be a dynamic notion tied to a library instance.
 
 Privacy is indicated by the name of a declaration - hence privacy and naming are not orthogonal. This has the advantage that both humans and machines can recognize access to private declarations at the point of use without knowledge of the context from which the declaration is derived.}
 
 \subsection{Concurrency}
 
 Dart code is always single threaded. There is no shared-state concurrency in Dart. Concurrency is supported via actor-like entities called {\em isolates}.
 
@@ skipping 1426 matching lines @@
 
 
 \subsubsection{Inheritance and Overriding}
 \label{interfaceInheritanceAndOverriding}
 
 Let $J$ be an interface and $K$ be a library. We define $inherited(J, K)$  to be the set of members $m$ such that   all of the following hold:
 \begin{itemize}
 \item $m$ is accessible to $K$ and 
 \item $A$ is a direct superinterface of $J$ and either 
   \begin{itemize}
-  \item $m$ is a member of  $A$  or
+  \item $A$ declares a member $m$  or
   \item $m$ is a member of $inherited(A, K)$.
   \end{itemize}
 \item $m$ is not overridden by $J$.
 \end{itemize}
 
 Furthermore, we define $overrides(J, K)$  to be the set of members $m^\prime$ such that  all of the following hold:
 \begin{itemize}
 \item $J$ is the implicit interface of a class $C$.
 \item  $C$ declares a member $m$.
 \item $m^\prime$ has the same name as $m$.
 \item $m^\prime$ is accessible to $K$.  
 \item $A$ is a direct superinterface of $J$ and either
   \begin{itemize}
-  \item $m^\prime$ is a member of $A$ or 
+  \item $A$ declares a member $m^\prime$ or 
   \item $m^\prime$ is a member of $inherited(A, K)$.
   \end{itemize}
 \end{itemize}
 
 
 Let $I$ be the implicit interface of a class $C$ declared in library $L$.  $I$ {\em inherits} all members of $inherited(I, L)$ and $I$ {\em overrides} $m^\prime$ if  $m^\prime \in overrides(I, L)$. 
 
 All the static warnings pertaining to the overriding of instance members given in section \ref{classes} above hold for overriding between interfaces as well.
 
 It is a static warning if $m$ is a method and $m^\prime$ is a getter, or if $m$ is a getter and $m^\prime$ is a method.
@@ skipping 3130 matching lines @@
 
 %\end{dartCode}
 
 %\rationale{therefore, we opt for the second option. Alternately, one could insist that assert be a reserved word, which may have an undesirable effect with respect to compatibility of Javascript code ported to Dart.}
 
 \section{Libraries and Scripts}
 \label{librariesAndScripts}
 
 A Dart program consists of one or more libraries, and may be built out of one or more {\em compilation units}. A compilation unit may be a library or a part (\ref{parts}). 
 
-A library consists of (a possibly empty) set of imports, a set of exports, and a set of top-level declarations. A top-level declaration is either a class (\ref{classes}), a type alias declaration (\ref{typedef}), a function (\ref{functions}) or a variable declaration (\ref{variables}). The members of a library $L$ are those top level declarations given within a $L$.
+A library consists of (a possibly empty) set of imports, a set of exports,  and a set of top-level declarations. A top-level declaration is either a class (\ref{classes}), a type alias declaration (\ref{typedef}), a function (\ref{functions}) or a variable declaration (\ref{variables}). The members of a library $L$ are those top level declarations given within a $L$.
 
  \begin{grammar}
 {\bf topLevelDefinition:}classDefinition;
 %      classDefinitionOrInterfaceInjection;
 %      interfaceDefinitionOrInterfaceInjection;
  %     mixinApplication;
       typeAlias;
       \EXTERNAL{}? functionSignature `{\escapegrammar ;}';
       \EXTERNAL{}? getterSignature `{\escapegrammar ;}';
       \EXTERNAL{}? setterSignature `{\escapegrammar ;}';      
@@ skipping 984 matching lines @@
 \item The names of compile time constant variables never use lower case letters. If they consist of multiple words, those words are separated by underscores. Examples: PI,  I\_AM\_A\_CONSTANT.
 \item The names of functions (including getters, setters, methods and local or library functions) and non-constant variables begin with a lowercase letter. If the name consists of multiple words, each  word (except the first) begins with an uppercase letter.  No other uppercase letters are used. Examples: camlCase, dart4TheWorld
 \item The names of types (including classes and type aliases) begin with an upper case letter.  If the name consists of multiple words, each  word  begins with an uppercase letter.  No other uppercase letters are used. Examples: CamlCase, Dart4TheWorld.
 \item The names of type variables are short (preferably single letter). Examples: T, S, K, V , E.
 \item The names of libraries or library prefixes never use upper case letters. If they consist of multiple words, those words are separated by underscores. Example: my\_favorite\_library.
 \end{itemize}
 }
 
 
 \end{document}